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


262379dab81e65f97d7596df8ebaf3073fd57da4
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29 /***********************************************************************
30 *
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 *
34 ************************************************************************/
35
36 /* template workaround for compilers that cannot correctly implement the C++ standard */
37 #ifndef SWIGTEMPLATEDISAMBIGUATOR
38 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 #endif
44
45 /* inline attribute */
46 #ifndef SWIGINLINE
47 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
48 # define SWIGINLINE inline
49 # else
50 # define SWIGINLINE
51 # endif
52 #endif
53
54 /* attribute recognised by some compilers to avoid 'unused' warnings */
55 #ifndef SWIGUNUSED
56 # if defined(__GNUC__) || defined(__ICC)
57 # define SWIGUNUSED __attribute__ ((unused))
58 # else
59 # define SWIGUNUSED
60 # endif
61 #endif
62
63 /* internal SWIG method */
64 #ifndef SWIGINTERN
65 # define SWIGINTERN static SWIGUNUSED
66 #endif
67
68 /* internal inline SWIG method */
69 #ifndef SWIGINTERNINLINE
70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
71 #endif
72
73 /* exporting methods for Windows DLLs */
74 #ifndef SWIGEXPORT
75 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
76 # if defined(STATIC_LINKED)
77 # define SWIGEXPORT
78 # else
79 # define SWIGEXPORT __declspec(dllexport)
80 # endif
81 # else
82 # define SWIGEXPORT
83 # endif
84 #endif
85
86 /* calling conventions for Windows */
87 #ifndef SWIGSTDCALL
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # define SWIGSTDCALL __stdcall
90 # else
91 # define SWIGSTDCALL
92 # endif
93 #endif
94
95
96
97 #include <Python.h>
98
99 /***********************************************************************
100 * swigrun.swg
101 *
102 * This file contains generic CAPI SWIG runtime support for pointer
103 * type checking.
104 *
105 ************************************************************************/
106
107 /* This should only be incremented when either the layout of swig_type_info changes,
108 or for whatever reason, the runtime changes incompatibly */
109 #define SWIG_RUNTIME_VERSION "2"
110
111 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
112 #ifdef SWIG_TYPE_TABLE
113 # define SWIG_QUOTE_STRING(x) #x
114 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
115 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
116 #else
117 # define SWIG_TYPE_TABLE_NAME
118 #endif
119
120 /*
121 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
122 creating a static or dynamic library from the swig runtime code.
123 In 99.9% of the cases, swig just needs to declare them as 'static'.
124
125 But only do this if is strictly necessary, ie, if you have problems
126 with your compiler or so.
127 */
128
129 #ifndef SWIGRUNTIME
130 # define SWIGRUNTIME SWIGINTERN
131 #endif
132
133 #ifndef SWIGRUNTIMEINLINE
134 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
135 #endif
136
137 #include <string.h>
138
139 #ifdef __cplusplus
140 extern "C" {
141 #endif
142
143 typedef void *(*swig_converter_func)(void *);
144 typedef struct swig_type_info *(*swig_dycast_func)(void **);
145
146 /* Structure to store inforomation on one type */
147 typedef struct swig_type_info {
148 const char *name; /* mangled name of this type */
149 const char *str; /* human readable name of this type */
150 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
151 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
152 void *clientdata; /* language specific type data */
153 } swig_type_info;
154
155 /* Structure to store a type and conversion function used for casting */
156 typedef struct swig_cast_info {
157 swig_type_info *type; /* pointer to type that is equivalent to this type */
158 swig_converter_func converter; /* function to cast the void pointers */
159 struct swig_cast_info *next; /* pointer to next cast in linked list */
160 struct swig_cast_info *prev; /* pointer to the previous cast */
161 } swig_cast_info;
162
163 /* Structure used to store module information
164 * Each module generates one structure like this, and the runtime collects
165 * all of these structures and stores them in a circularly linked list.*/
166 typedef struct swig_module_info {
167 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
168 size_t size; /* Number of types in this module */
169 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
170 swig_type_info **type_initial; /* Array of initially generated type structures */
171 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
172 void *clientdata; /* Language specific module data */
173 } swig_module_info;
174
175
176 /*
177 Compare two type names skipping the space characters, therefore
178 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
179
180 Return 0 when the two name types are equivalent, as in
181 strncmp, but skipping ' '.
182 */
183 SWIGRUNTIME int
184 SWIG_TypeNameComp(const char *f1, const char *l1,
185 const char *f2, const char *l2) {
186 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
187 while ((*f1 == ' ') && (f1 != l1)) ++f1;
188 while ((*f2 == ' ') && (f2 != l2)) ++f2;
189 if (*f1 != *f2) return (int)(*f1 - *f2);
190 }
191 return (l1 - f1) - (l2 - f2);
192 }
193
194 /*
195 Check type equivalence in a name list like <name1>|<name2>|...
196 Return 0 if not equal, 1 if equal
197 */
198 SWIGRUNTIME int
199 SWIG_TypeEquiv(const char *nb, const char *tb) {
200 int equiv = 0;
201 const char* te = tb + strlen(tb);
202 const char* ne = nb;
203 while (!equiv && *ne) {
204 for (nb = ne; *ne; ++ne) {
205 if (*ne == '|') break;
206 }
207 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
208 if (*ne) ++ne;
209 }
210 return equiv;
211 }
212
213 /*
214 Check type equivalence in a name list like <name1>|<name2>|...
215 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
216 */
217 SWIGRUNTIME int
218 SWIG_TypeCompare(const char *nb, const char *tb) {
219 int equiv = 0;
220 const char* te = tb + strlen(tb);
221 const char* ne = nb;
222 while (!equiv && *ne) {
223 for (nb = ne; *ne; ++ne) {
224 if (*ne == '|') break;
225 }
226 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
227 if (*ne) ++ne;
228 }
229 return equiv;
230 }
231
232
233 /* think of this as a c++ template<> or a scheme macro */
234 #define SWIG_TypeCheck_Template(comparison, ty) \
235 if (ty) { \
236 swig_cast_info *iter = ty->cast; \
237 while (iter) { \
238 if (comparison) { \
239 if (iter == ty->cast) return iter; \
240 /* Move iter to the top of the linked list */ \
241 iter->prev->next = iter->next; \
242 if (iter->next) \
243 iter->next->prev = iter->prev; \
244 iter->next = ty->cast; \
245 iter->prev = 0; \
246 if (ty->cast) ty->cast->prev = iter; \
247 ty->cast = iter; \
248 return iter; \
249 } \
250 iter = iter->next; \
251 } \
252 } \
253 return 0
254
255 /*
256 Check the typename
257 */
258 SWIGRUNTIME swig_cast_info *
259 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
260 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
261 }
262
263 /* Same as previous function, except strcmp is replaced with a pointer comparison */
264 SWIGRUNTIME swig_cast_info *
265 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
266 SWIG_TypeCheck_Template(iter->type == from, into);
267 }
268
269 /*
270 Cast a pointer up an inheritance hierarchy
271 */
272 SWIGRUNTIMEINLINE void *
273 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
274 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
275 }
276
277 /*
278 Dynamic pointer casting. Down an inheritance hierarchy
279 */
280 SWIGRUNTIME swig_type_info *
281 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
282 swig_type_info *lastty = ty;
283 if (!ty || !ty->dcast) return ty;
284 while (ty && (ty->dcast)) {
285 ty = (*ty->dcast)(ptr);
286 if (ty) lastty = ty;
287 }
288 return lastty;
289 }
290
291 /*
292 Return the name associated with this type
293 */
294 SWIGRUNTIMEINLINE const char *
295 SWIG_TypeName(const swig_type_info *ty) {
296 return ty->name;
297 }
298
299 /*
300 Return the pretty name associated with this type,
301 that is an unmangled type name in a form presentable to the user.
302 */
303 SWIGRUNTIME const char *
304 SWIG_TypePrettyName(const swig_type_info *type) {
305 /* The "str" field contains the equivalent pretty names of the
306 type, separated by vertical-bar characters. We choose
307 to print the last name, as it is often (?) the most
308 specific. */
309 if (type->str != NULL) {
310 const char *last_name = type->str;
311 const char *s;
312 for (s = type->str; *s; s++)
313 if (*s == '|') last_name = s+1;
314 return last_name;
315 }
316 else
317 return type->name;
318 }
319
320 /*
321 Set the clientdata field for a type
322 */
323 SWIGRUNTIME void
324 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
325 swig_cast_info *cast = ti->cast;
326 /* if (ti->clientdata == clientdata) return; */
327 ti->clientdata = clientdata;
328
329 while (cast) {
330 if (!cast->converter) {
331 swig_type_info *tc = cast->type;
332 if (!tc->clientdata) {
333 SWIG_TypeClientData(tc, clientdata);
334 }
335 }
336 cast = cast->next;
337 }
338 }
339
340 /*
341 Search for a swig_type_info structure only by mangled name
342 Search is a O(log #types)
343
344 We start searching at module start, and finish searching when start == end.
345 Note: if start == end at the beginning of the function, we go all the way around
346 the circular list.
347 */
348 SWIGRUNTIME swig_type_info *
349 SWIG_MangledTypeQueryModule(swig_module_info *start,
350 swig_module_info *end,
351 const char *name) {
352 swig_module_info *iter = start;
353 do {
354 if (iter->size) {
355 register size_t l = 0;
356 register size_t r = iter->size - 1;
357 do {
358 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
359 register size_t i = (l + r) >> 1;
360 const char *iname = iter->types[i]->name;
361 if (iname) {
362 register int compare = strcmp(name, iname);
363 if (compare == 0) {
364 return iter->types[i];
365 } else if (compare < 0) {
366 if (i) {
367 r = i - 1;
368 } else {
369 break;
370 }
371 } else if (compare > 0) {
372 l = i + 1;
373 }
374 } else {
375 break; /* should never happen */
376 }
377 } while (l <= r);
378 }
379 iter = iter->next;
380 } while (iter != end);
381 return 0;
382 }
383
384 /*
385 Search for a swig_type_info structure for either a mangled name or a human readable name.
386 It first searches the mangled names of the types, which is a O(log #types)
387 If a type is not found it then searches the human readable names, which is O(#types).
388
389 We start searching at module start, and finish searching when start == end.
390 Note: if start == end at the beginning of the function, we go all the way around
391 the circular list.
392 */
393 SWIGRUNTIME swig_type_info *
394 SWIG_TypeQueryModule(swig_module_info *start,
395 swig_module_info *end,
396 const char *name) {
397 /* STEP 1: Search the name field using binary search */
398 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
399 if (ret) {
400 return ret;
401 } else {
402 /* STEP 2: If the type hasn't been found, do a complete search
403 of the str field (the human readable name) */
404 swig_module_info *iter = start;
405 do {
406 register size_t i = 0;
407 for (; i < iter->size; ++i) {
408 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
409 return iter->types[i];
410 }
411 iter = iter->next;
412 } while (iter != end);
413 }
414
415 /* neither found a match */
416 return 0;
417 }
418
419
420 /*
421 Pack binary data into a string
422 */
423 SWIGRUNTIME char *
424 SWIG_PackData(char *c, void *ptr, size_t sz) {
425 static const char hex[17] = "0123456789abcdef";
426 register const unsigned char *u = (unsigned char *) ptr;
427 register const unsigned char *eu = u + sz;
428 for (; u != eu; ++u) {
429 register unsigned char uu = *u;
430 *(c++) = hex[(uu & 0xf0) >> 4];
431 *(c++) = hex[uu & 0xf];
432 }
433 return c;
434 }
435
436 /*
437 Unpack binary data from a string
438 */
439 SWIGRUNTIME const char *
440 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
441 register unsigned char *u = (unsigned char *) ptr;
442 register const unsigned char *eu = u + sz;
443 for (; u != eu; ++u) {
444 register char d = *(c++);
445 register unsigned char uu = 0;
446 if ((d >= '0') && (d <= '9'))
447 uu = ((d - '0') << 4);
448 else if ((d >= 'a') && (d <= 'f'))
449 uu = ((d - ('a'-10)) << 4);
450 else
451 return (char *) 0;
452 d = *(c++);
453 if ((d >= '0') && (d <= '9'))
454 uu |= (d - '0');
455 else if ((d >= 'a') && (d <= 'f'))
456 uu |= (d - ('a'-10));
457 else
458 return (char *) 0;
459 *u = uu;
460 }
461 return c;
462 }
463
464 /*
465 Pack 'void *' into a string buffer.
466 */
467 SWIGRUNTIME char *
468 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
469 char *r = buff;
470 if ((2*sizeof(void *) + 2) > bsz) return 0;
471 *(r++) = '_';
472 r = SWIG_PackData(r,&ptr,sizeof(void *));
473 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
474 strcpy(r,name);
475 return buff;
476 }
477
478 SWIGRUNTIME const char *
479 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
480 if (*c != '_') {
481 if (strcmp(c,"NULL") == 0) {
482 *ptr = (void *) 0;
483 return name;
484 } else {
485 return 0;
486 }
487 }
488 return SWIG_UnpackData(++c,ptr,sizeof(void *));
489 }
490
491 SWIGRUNTIME char *
492 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
493 char *r = buff;
494 size_t lname = (name ? strlen(name) : 0);
495 if ((2*sz + 2 + lname) > bsz) return 0;
496 *(r++) = '_';
497 r = SWIG_PackData(r,ptr,sz);
498 if (lname) {
499 strncpy(r,name,lname+1);
500 } else {
501 *r = 0;
502 }
503 return buff;
504 }
505
506 SWIGRUNTIME const char *
507 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
508 if (*c != '_') {
509 if (strcmp(c,"NULL") == 0) {
510 memset(ptr,0,sz);
511 return name;
512 } else {
513 return 0;
514 }
515 }
516 return SWIG_UnpackData(++c,ptr,sz);
517 }
518
519 #ifdef __cplusplus
520 }
521 #endif
522
523 /* -----------------------------------------------------------------------------
524 * SWIG API. Portion that goes into the runtime
525 * ----------------------------------------------------------------------------- */
526
527 #ifdef __cplusplus
528 extern "C" {
529 #endif
530
531 /* -----------------------------------------------------------------------------
532 * for internal method declarations
533 * ----------------------------------------------------------------------------- */
534
535 #ifndef SWIGINTERN
536 # define SWIGINTERN static SWIGUNUSED
537 #endif
538
539 #ifndef SWIGINTERNINLINE
540 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
541 #endif
542
543 /*
544 Exception handling in wrappers
545 */
546 #define SWIG_fail goto fail
547 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
548 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
549 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
550 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
551 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
552
553 /*
554 Contract support
555 */
556 #define SWIG_contract_assert(expr, msg) \
557 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
558
559 /* -----------------------------------------------------------------------------
560 * Constant declarations
561 * ----------------------------------------------------------------------------- */
562
563 /* Constant Types */
564 #define SWIG_PY_INT 1
565 #define SWIG_PY_FLOAT 2
566 #define SWIG_PY_STRING 3
567 #define SWIG_PY_POINTER 4
568 #define SWIG_PY_BINARY 5
569
570 /* Constant information structure */
571 typedef struct swig_const_info {
572 int type;
573 char *name;
574 long lvalue;
575 double dvalue;
576 void *pvalue;
577 swig_type_info **ptype;
578 } swig_const_info;
579
580
581 /* -----------------------------------------------------------------------------
582 * Alloc. memory flags
583 * ----------------------------------------------------------------------------- */
584 #define SWIG_OLDOBJ 1
585 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
586 #define SWIG_PYSTR SWIG_NEWOBJ + 1
587
588 #ifdef __cplusplus
589 }
590 #endif
591
592
593 /***********************************************************************
594 * pyrun.swg
595 *
596 * This file contains the runtime support for Python modules
597 * and includes code for managing global variables and pointer
598 * type checking.
599 *
600 * Author : David Beazley (beazley@cs.uchicago.edu)
601 ************************************************************************/
602
603 /* Common SWIG API */
604 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
605 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
606 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
607
608
609 /* Python-specific SWIG API */
610 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
611 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
612
613 /* Runtime API */
614 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
615 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
616
617 /* -----------------------------------------------------------------------------
618 * Pointer declarations
619 * ----------------------------------------------------------------------------- */
620 /*
621 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
622 C/C++ pointers in the python side. Very useful for debugging, but
623 not always safe.
624 */
625 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
626 # define SWIG_COBJECT_TYPES
627 #endif
628
629 /* Flags for pointer conversion */
630 #define SWIG_POINTER_EXCEPTION 0x1
631 #define SWIG_POINTER_DISOWN 0x2
632
633
634 /* Add PyOS_snprintf for old Pythons */
635 #if PY_VERSION_HEX < 0x02020000
636 #define PyOS_snprintf snprintf
637 #endif
638
639 #ifdef __cplusplus
640 extern "C" {
641 #endif
642
643 /* -----------------------------------------------------------------------------
644 * Create a new pointer string
645 * ----------------------------------------------------------------------------- */
646 #ifndef SWIG_BUFFER_SIZE
647 #define SWIG_BUFFER_SIZE 1024
648 #endif
649
650 /* A crude PyString_FromFormat implementation for old Pythons */
651 #if PY_VERSION_HEX < 0x02020000
652 static PyObject *
653 PyString_FromFormat(const char *fmt, ...) {
654 va_list ap;
655 char buf[SWIG_BUFFER_SIZE * 2];
656 int res;
657 va_start(ap, fmt);
658 res = vsnprintf(buf, sizeof(buf), fmt, ap);
659 va_end(ap);
660 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
661 }
662 #endif
663
664 #if PY_VERSION_HEX < 0x01060000
665 #define PyObject_Del(op) PyMem_DEL((op))
666 #endif
667
668 #if defined(SWIG_COBJECT_TYPES)
669 #if !defined(SWIG_COBJECT_PYTHON)
670 /* -----------------------------------------------------------------------------
671 * Implements a simple Swig Object type, and use it instead of PyCObject
672 * ----------------------------------------------------------------------------- */
673
674 typedef struct {
675 PyObject_HEAD
676 void *ptr;
677 const char *desc;
678 } PySwigObject;
679
680 /* Declarations for objects of type PySwigObject */
681
682 SWIGRUNTIME int
683 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
684 {
685 char result[SWIG_BUFFER_SIZE];
686 flags = flags;
687 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
688 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
689 return 0;
690 } else {
691 return 1;
692 }
693 }
694
695 SWIGRUNTIME PyObject *
696 PySwigObject_repr(PySwigObject *v)
697 {
698 char result[SWIG_BUFFER_SIZE];
699 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
700 PyString_FromFormat("<Swig Object at %s>", result) : 0;
701 }
702
703 SWIGRUNTIME PyObject *
704 PySwigObject_str(PySwigObject *v)
705 {
706 char result[SWIG_BUFFER_SIZE];
707 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
708 PyString_FromString(result) : 0;
709 }
710
711 SWIGRUNTIME PyObject *
712 PySwigObject_long(PySwigObject *v)
713 {
714 return PyLong_FromVoidPtr(v->ptr);
715 }
716
717 SWIGRUNTIME PyObject *
718 PySwigObject_format(const char* fmt, PySwigObject *v)
719 {
720 PyObject *res = NULL;
721 PyObject *args = PyTuple_New(1);
722 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
723 PyObject *ofmt = PyString_FromString(fmt);
724 if (ofmt) {
725 res = PyString_Format(ofmt,args);
726 Py_DECREF(ofmt);
727 }
728 Py_DECREF(args);
729 }
730 return res;
731 }
732
733 SWIGRUNTIME PyObject *
734 PySwigObject_oct(PySwigObject *v)
735 {
736 return PySwigObject_format("%o",v);
737 }
738
739 SWIGRUNTIME PyObject *
740 PySwigObject_hex(PySwigObject *v)
741 {
742 return PySwigObject_format("%x",v);
743 }
744
745 SWIGRUNTIME int
746 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
747 {
748 int c = strcmp(v->desc, w->desc);
749 if (c) {
750 return (c > 0) ? 1 : -1;
751 } else {
752 void *i = v->ptr;
753 void *j = w->ptr;
754 return (i < j) ? -1 : ((i > j) ? 1 : 0);
755 }
756 }
757
758 SWIGRUNTIME void
759 PySwigObject_dealloc(PySwigObject *self)
760 {
761 PyObject_Del(self);
762 }
763
764 SWIGRUNTIME PyTypeObject*
765 PySwigObject_type(void) {
766 static char pyswigobject_type__doc__[] =
767 "Swig object carries a C/C++ instance pointer";
768
769 static PyNumberMethods PySwigObject_as_number = {
770 (binaryfunc)0, /*nb_add*/
771 (binaryfunc)0, /*nb_subtract*/
772 (binaryfunc)0, /*nb_multiply*/
773 (binaryfunc)0, /*nb_divide*/
774 (binaryfunc)0, /*nb_remainder*/
775 (binaryfunc)0, /*nb_divmod*/
776 (ternaryfunc)0,/*nb_power*/
777 (unaryfunc)0, /*nb_negative*/
778 (unaryfunc)0, /*nb_positive*/
779 (unaryfunc)0, /*nb_absolute*/
780 (inquiry)0, /*nb_nonzero*/
781 0, /*nb_invert*/
782 0, /*nb_lshift*/
783 0, /*nb_rshift*/
784 0, /*nb_and*/
785 0, /*nb_xor*/
786 0, /*nb_or*/
787 (coercion)0, /*nb_coerce*/
788 (unaryfunc)PySwigObject_long, /*nb_int*/
789 (unaryfunc)PySwigObject_long, /*nb_long*/
790 (unaryfunc)0, /*nb_float*/
791 (unaryfunc)PySwigObject_oct, /*nb_oct*/
792 (unaryfunc)PySwigObject_hex, /*nb_hex*/
793 #if PY_VERSION_HEX >= 0x02020000
794 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
795 #elif PY_VERSION_HEX >= 0x02000000
796 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
797 #endif
798 };
799
800 static PyTypeObject pyswigobject_type
801 #if !defined(__cplusplus)
802 ;
803 static int type_init = 0;
804 if (!type_init) {
805 PyTypeObject tmp
806 #endif
807 = {
808 PyObject_HEAD_INIT(&PyType_Type)
809 0, /*ob_size*/
810 (char *)"PySwigObject", /*tp_name*/
811 sizeof(PySwigObject), /*tp_basicsize*/
812 0, /*tp_itemsize*/
813 /* methods */
814 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
815 (printfunc)PySwigObject_print, /*tp_print*/
816 (getattrfunc)0, /*tp_getattr*/
817 (setattrfunc)0, /*tp_setattr*/
818 (cmpfunc)PySwigObject_compare, /*tp_compare*/
819 (reprfunc)PySwigObject_repr, /*tp_repr*/
820 &PySwigObject_as_number, /*tp_as_number*/
821 0, /*tp_as_sequence*/
822 0, /*tp_as_mapping*/
823 (hashfunc)0, /*tp_hash*/
824 (ternaryfunc)0, /*tp_call*/
825 (reprfunc)PySwigObject_str, /*tp_str*/
826 /* Space for future expansion */
827 0,0,0,0,
828 pyswigobject_type__doc__, /* Documentation string */
829 #if PY_VERSION_HEX >= 0x02000000
830 0, /* tp_traverse */
831 0, /* tp_clear */
832 #endif
833 #if PY_VERSION_HEX >= 0x02010000
834 0, /* tp_richcompare */
835 0, /* tp_weaklistoffset */
836 #endif
837 #if PY_VERSION_HEX >= 0x02020000
838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
839 #endif
840 #if PY_VERSION_HEX >= 0x02030000
841 0, /* tp_del */
842 #endif
843 #ifdef COUNT_ALLOCS
844 0,0,0,0 /* tp_alloc -> tp_next */
845 #endif
846 };
847 #if !defined(__cplusplus)
848 pyswigobject_type = tmp;
849 type_init = 1;
850 }
851 #endif
852 return &pyswigobject_type;
853 }
854
855 SWIGRUNTIME PyObject *
856 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
857 {
858 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
859 if (self) {
860 self->ptr = ptr;
861 self->desc = desc;
862 }
863 return (PyObject *)self;
864 }
865
866 SWIGRUNTIMEINLINE void *
867 PySwigObject_AsVoidPtr(PyObject *self)
868 {
869 return ((PySwigObject *)self)->ptr;
870 }
871
872 SWIGRUNTIMEINLINE const char *
873 PySwigObject_GetDesc(PyObject *self)
874 {
875 return ((PySwigObject *)self)->desc;
876 }
877
878 SWIGRUNTIMEINLINE int
879 PySwigObject_Check(PyObject *op) {
880 return ((op)->ob_type == PySwigObject_type())
881 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
882 }
883
884 /* -----------------------------------------------------------------------------
885 * Implements a simple Swig Packed type, and use it instead of string
886 * ----------------------------------------------------------------------------- */
887
888 typedef struct {
889 PyObject_HEAD
890 void *pack;
891 const char *desc;
892 size_t size;
893 } PySwigPacked;
894
895 SWIGRUNTIME int
896 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
897 {
898 char result[SWIG_BUFFER_SIZE];
899 flags = flags;
900 fputs("<Swig Packed ", fp);
901 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
902 fputs("at ", fp);
903 fputs(result, fp);
904 }
905 fputs(v->desc,fp);
906 fputs(">", fp);
907 return 0;
908 }
909
910 SWIGRUNTIME PyObject *
911 PySwigPacked_repr(PySwigPacked *v)
912 {
913 char result[SWIG_BUFFER_SIZE];
914 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
915 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
916 } else {
917 return PyString_FromFormat("<Swig Packed %s>", v->desc);
918 }
919 }
920
921 SWIGRUNTIME PyObject *
922 PySwigPacked_str(PySwigPacked *v)
923 {
924 char result[SWIG_BUFFER_SIZE];
925 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
926 return PyString_FromFormat("%s%s", result, v->desc);
927 } else {
928 return PyString_FromString(v->desc);
929 }
930 }
931
932 SWIGRUNTIME int
933 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
934 {
935 int c = strcmp(v->desc, w->desc);
936 if (c) {
937 return (c > 0) ? 1 : -1;
938 } else {
939 size_t i = v->size;
940 size_t j = w->size;
941 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
942 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
943 }
944 }
945
946 SWIGRUNTIME void
947 PySwigPacked_dealloc(PySwigPacked *self)
948 {
949 free(self->pack);
950 PyObject_Del(self);
951 }
952
953 SWIGRUNTIME PyTypeObject*
954 PySwigPacked_type(void) {
955 static char pyswigpacked_type__doc__[] =
956 "Swig object carries a C/C++ instance pointer";
957 static PyTypeObject pyswigpacked_type
958 #if !defined(__cplusplus)
959 ;
960 static int type_init = 0;
961 if (!type_init) {
962 PyTypeObject tmp
963 #endif
964 = {
965 PyObject_HEAD_INIT(&PyType_Type)
966 0, /*ob_size*/
967 (char *)"PySwigPacked", /*tp_name*/
968 sizeof(PySwigPacked), /*tp_basicsize*/
969 0, /*tp_itemsize*/
970 /* methods */
971 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
972 (printfunc)PySwigPacked_print, /*tp_print*/
973 (getattrfunc)0, /*tp_getattr*/
974 (setattrfunc)0, /*tp_setattr*/
975 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
976 (reprfunc)PySwigPacked_repr, /*tp_repr*/
977 0, /*tp_as_number*/
978 0, /*tp_as_sequence*/
979 0, /*tp_as_mapping*/
980 (hashfunc)0, /*tp_hash*/
981 (ternaryfunc)0, /*tp_call*/
982 (reprfunc)PySwigPacked_str, /*tp_str*/
983 /* Space for future expansion */
984 0,0,0,0,
985 pyswigpacked_type__doc__, /* Documentation string */
986 #if PY_VERSION_HEX >= 0x02000000
987 0, /* tp_traverse */
988 0, /* tp_clear */
989 #endif
990 #if PY_VERSION_HEX >= 0x02010000
991 0, /* tp_richcompare */
992 0, /* tp_weaklistoffset */
993 #endif
994 #if PY_VERSION_HEX >= 0x02020000
995 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
996 #endif
997 #if PY_VERSION_HEX >= 0x02030000
998 0, /* tp_del */
999 #endif
1000 #ifdef COUNT_ALLOCS
1001 0,0,0,0 /* tp_alloc -> tp_next */
1002 #endif
1003 };
1004 #if !defined(__cplusplus)
1005 pyswigpacked_type = tmp;
1006 type_init = 1;
1007 }
1008 #endif
1009 return &pyswigpacked_type;
1010 }
1011
1012 SWIGRUNTIME PyObject *
1013 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1014 {
1015 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1016 if (self == NULL) {
1017 return NULL;
1018 } else {
1019 void *pack = malloc(size);
1020 if (pack) {
1021 memcpy(pack, ptr, size);
1022 self->pack = pack;
1023 self->desc = desc;
1024 self->size = size;
1025 return (PyObject *) self;
1026 }
1027 return NULL;
1028 }
1029 }
1030
1031 SWIGRUNTIMEINLINE const char *
1032 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1033 {
1034 PySwigPacked *self = (PySwigPacked *)obj;
1035 if (self->size != size) return 0;
1036 memcpy(ptr, self->pack, size);
1037 return self->desc;
1038 }
1039
1040 SWIGRUNTIMEINLINE const char *
1041 PySwigPacked_GetDesc(PyObject *self)
1042 {
1043 return ((PySwigPacked *)self)->desc;
1044 }
1045
1046 SWIGRUNTIMEINLINE int
1047 PySwigPacked_Check(PyObject *op) {
1048 return ((op)->ob_type == PySwigPacked_type())
1049 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1050 }
1051
1052 #else
1053 /* -----------------------------------------------------------------------------
1054 * Use the old Python PyCObject instead of PySwigObject
1055 * ----------------------------------------------------------------------------- */
1056
1057 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1058 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1059 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1060 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1061
1062 #endif
1063
1064 #endif
1065
1066 /* -----------------------------------------------------------------------------
1067 * errors manipulation
1068 * ----------------------------------------------------------------------------- */
1069
1070 SWIGRUNTIME void
1071 SWIG_Python_TypeError(const char *type, PyObject *obj)
1072 {
1073 if (type) {
1074 #if defined(SWIG_COBJECT_TYPES)
1075 if (obj && PySwigObject_Check(obj)) {
1076 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1077 if (otype) {
1078 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1079 type, otype);
1080 return;
1081 }
1082 } else
1083 #endif
1084 {
1085 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1086 if (otype) {
1087 PyObject *str = PyObject_Str(obj);
1088 const char *cstr = str ? PyString_AsString(str) : 0;
1089 if (cstr) {
1090 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1091 type, otype, cstr);
1092 } else {
1093 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1094 type, otype);
1095 }
1096 Py_XDECREF(str);
1097 return;
1098 }
1099 }
1100 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1101 } else {
1102 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1103 }
1104 }
1105
1106 SWIGRUNTIMEINLINE void
1107 SWIG_Python_NullRef(const char *type)
1108 {
1109 if (type) {
1110 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1111 } else {
1112 PyErr_Format(PyExc_TypeError, "null reference was received");
1113 }
1114 }
1115
1116 SWIGRUNTIME int
1117 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1118 {
1119 if (PyErr_Occurred()) {
1120 PyObject *type = 0;
1121 PyObject *value = 0;
1122 PyObject *traceback = 0;
1123 PyErr_Fetch(&type, &value, &traceback);
1124 if (value) {
1125 PyObject *old_str = PyObject_Str(value);
1126 Py_XINCREF(type);
1127 PyErr_Clear();
1128 if (infront) {
1129 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1130 } else {
1131 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1132 }
1133 Py_DECREF(old_str);
1134 }
1135 return 1;
1136 } else {
1137 return 0;
1138 }
1139 }
1140
1141 SWIGRUNTIME int
1142 SWIG_Python_ArgFail(int argnum)
1143 {
1144 if (PyErr_Occurred()) {
1145 /* add information about failing argument */
1146 char mesg[256];
1147 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1148 return SWIG_Python_AddErrMesg(mesg, 1);
1149 } else {
1150 return 0;
1151 }
1152 }
1153
1154
1155 /* -----------------------------------------------------------------------------
1156 * pointers/data manipulation
1157 * ----------------------------------------------------------------------------- */
1158
1159 /* Convert a pointer value */
1160 SWIGRUNTIME int
1161 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1162 swig_cast_info *tc;
1163 const char *c = 0;
1164 static PyObject *SWIG_this = 0;
1165 int newref = 0;
1166 PyObject *pyobj = 0;
1167 void *vptr;
1168
1169 if (!obj) return 0;
1170 if (obj == Py_None) {
1171 *ptr = 0;
1172 return 0;
1173 }
1174
1175 #ifdef SWIG_COBJECT_TYPES
1176 if (!(PySwigObject_Check(obj))) {
1177 if (!SWIG_this)
1178 SWIG_this = PyString_FromString("this");
1179 pyobj = obj;
1180 obj = PyObject_GetAttr(obj,SWIG_this);
1181 newref = 1;
1182 if (!obj) goto type_error;
1183 if (!PySwigObject_Check(obj)) {
1184 Py_DECREF(obj);
1185 goto type_error;
1186 }
1187 }
1188 vptr = PySwigObject_AsVoidPtr(obj);
1189 c = (const char *) PySwigObject_GetDesc(obj);
1190 if (newref) { Py_DECREF(obj); }
1191 goto type_check;
1192 #else
1193 if (!(PyString_Check(obj))) {
1194 if (!SWIG_this)
1195 SWIG_this = PyString_FromString("this");
1196 pyobj = obj;
1197 obj = PyObject_GetAttr(obj,SWIG_this);
1198 newref = 1;
1199 if (!obj) goto type_error;
1200 if (!PyString_Check(obj)) {
1201 Py_DECREF(obj);
1202 goto type_error;
1203 }
1204 }
1205 c = PyString_AsString(obj);
1206 /* Pointer values must start with leading underscore */
1207 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1208 if (newref) { Py_DECREF(obj); }
1209 if (!c) goto type_error;
1210 #endif
1211
1212 type_check:
1213 if (ty) {
1214 tc = SWIG_TypeCheck(c,ty);
1215 if (!tc) goto type_error;
1216 *ptr = SWIG_TypeCast(tc,vptr);
1217 } else {
1218 *ptr = vptr;
1219 }
1220 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1221 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1222 }
1223 return 0;
1224
1225 type_error:
1226 PyErr_Clear();
1227 if (pyobj && !obj) {
1228 obj = pyobj;
1229 if (PyCFunction_Check(obj)) {
1230 /* here we get the method pointer for callbacks */
1231 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1232 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1233 if (c) {
1234 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1235 if (!c) goto type_error;
1236 goto type_check;
1237 }
1238 }
1239 }
1240 if (flags & SWIG_POINTER_EXCEPTION) {
1241 if (ty) {
1242 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1243 } else {
1244 SWIG_Python_TypeError("C/C++ pointer", obj);
1245 }
1246 }
1247 return -1;
1248 }
1249
1250 /* Convert a pointer value, signal an exception on a type mismatch */
1251 SWIGRUNTIME void *
1252 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1253 void *result;
1254 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1255 PyErr_Clear();
1256 if (flags & SWIG_POINTER_EXCEPTION) {
1257 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1258 SWIG_Python_ArgFail(argnum);
1259 }
1260 }
1261 return result;
1262 }
1263
1264 /* Convert a packed value value */
1265 SWIGRUNTIME int
1266 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1267 swig_cast_info *tc;
1268 const char *c = 0;
1269
1270 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1271 c = PySwigPacked_UnpackData(obj, ptr, sz);
1272 #else
1273 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1274 c = PyString_AsString(obj);
1275 /* Pointer values must start with leading underscore */
1276 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1277 #endif
1278 if (!c) goto type_error;
1279 if (ty) {
1280 tc = SWIG_TypeCheck(c,ty);
1281 if (!tc) goto type_error;
1282 }
1283 return 0;
1284
1285 type_error:
1286 PyErr_Clear();
1287 if (flags & SWIG_POINTER_EXCEPTION) {
1288 if (ty) {
1289 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1290 } else {
1291 SWIG_Python_TypeError("C/C++ packed data", obj);
1292 }
1293 }
1294 return -1;
1295 }
1296
1297 /* Create a new array object */
1298 SWIGRUNTIME PyObject *
1299 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1300 PyObject *robj = 0;
1301 if (!type) {
1302 if (!PyErr_Occurred()) {
1303 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1304 }
1305 return robj;
1306 }
1307 if (!ptr) {
1308 Py_INCREF(Py_None);
1309 return Py_None;
1310 }
1311 #ifdef SWIG_COBJECT_TYPES
1312 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1313 #else
1314 {
1315 char result[SWIG_BUFFER_SIZE];
1316 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1317 PyString_FromString(result) : 0;
1318 }
1319 #endif
1320 if (!robj || (robj == Py_None)) return robj;
1321 if (type->clientdata) {
1322 PyObject *inst;
1323 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1324 Py_DECREF(robj);
1325 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1326 Py_DECREF(args);
1327 if (inst) {
1328 if (own) {
1329 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1330 }
1331 robj = inst;
1332 }
1333 }
1334 return robj;
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1339 PyObject *robj = 0;
1340 if (!ptr) {
1341 Py_INCREF(Py_None);
1342 return Py_None;
1343 }
1344 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1345 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1346 #else
1347 {
1348 char result[SWIG_BUFFER_SIZE];
1349 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1350 PyString_FromString(result) : 0;
1351 }
1352 #endif
1353 return robj;
1354 }
1355
1356 /* -----------------------------------------------------------------------------*
1357 * Get type list
1358 * -----------------------------------------------------------------------------*/
1359
1360 #ifdef SWIG_LINK_RUNTIME
1361 void *SWIG_ReturnGlobalTypeList(void *);
1362 #endif
1363
1364 SWIGRUNTIME swig_module_info *
1365 SWIG_Python_GetModule(void) {
1366 static void *type_pointer = (void *)0;
1367 /* first check if module already created */
1368 if (!type_pointer) {
1369 #ifdef SWIG_LINK_RUNTIME
1370 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1371 #else
1372 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1373 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1374 if (PyErr_Occurred()) {
1375 PyErr_Clear();
1376 type_pointer = (void *)0;
1377 }
1378 #endif
1379 }
1380 return (swig_module_info *) type_pointer;
1381 }
1382
1383 #if PY_MAJOR_VERSION < 2
1384 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1385 is copied out of Python/modsupport.c in python version 2.3.4 */
1386 SWIGINTERN int
1387 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1388 {
1389 PyObject *dict;
1390 if (!PyModule_Check(m)) {
1391 PyErr_SetString(PyExc_TypeError,
1392 "PyModule_AddObject() needs module as first arg");
1393 return -1;
1394 }
1395 if (!o) {
1396 PyErr_SetString(PyExc_TypeError,
1397 "PyModule_AddObject() needs non-NULL value");
1398 return -1;
1399 }
1400
1401 dict = PyModule_GetDict(m);
1402 if (dict == NULL) {
1403 /* Internal error -- modules must have a dict! */
1404 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1405 PyModule_GetName(m));
1406 return -1;
1407 }
1408 if (PyDict_SetItemString(dict, name, o))
1409 return -1;
1410 Py_DECREF(o);
1411 return 0;
1412 }
1413 #endif
1414
1415 SWIGRUNTIME void
1416 SWIG_Python_SetModule(swig_module_info *swig_module) {
1417 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1418
1419 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1420 swig_empty_runtime_method_table);
1421 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1422 if (pointer && module) {
1423 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1424 }
1425 }
1426
1427 #ifdef __cplusplus
1428 }
1429 #endif
1430
1431
1432 /* -------- TYPES TABLE (BEGIN) -------- */
1433
1434 #define SWIGTYPE_p_buffer swig_types[0]
1435 #define SWIGTYPE_p_char swig_types[1]
1436 #define SWIGTYPE_p_form_ops_t swig_types[2]
1437 #define SWIGTYPE_p_int swig_types[3]
1438 #define SWIGTYPE_p_long swig_types[4]
1439 #define SWIGTYPE_p_unsigned_char swig_types[5]
1440 #define SWIGTYPE_p_unsigned_int swig_types[6]
1441 #define SWIGTYPE_p_unsigned_long swig_types[7]
1442 #define SWIGTYPE_p_wxANIHandler swig_types[8]
1443 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
1444 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
1445 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
1446 #define SWIGTYPE_p_wxAppTraits swig_types[12]
1447 #define SWIGTYPE_p_wxArrayString swig_types[13]
1448 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
1449 #define SWIGTYPE_p_wxBitmap swig_types[15]
1450 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
1451 #define SWIGTYPE_p_wxButton swig_types[17]
1452 #define SWIGTYPE_p_wxCURHandler swig_types[18]
1453 #define SWIGTYPE_p_wxCaret swig_types[19]
1454 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
1456 #define SWIGTYPE_p_wxColour swig_types[22]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
1458 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
1459 #define SWIGTYPE_p_wxControl swig_types[25]
1460 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
1461 #define SWIGTYPE_p_wxCursor swig_types[27]
1462 #define SWIGTYPE_p_wxDC swig_types[28]
1463 #define SWIGTYPE_p_wxDateEvent swig_types[29]
1464 #define SWIGTYPE_p_wxDateTime swig_types[30]
1465 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
1466 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
1467 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
1468 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
1469 #define SWIGTYPE_p_wxEvent swig_types[35]
1470 #define SWIGTYPE_p_wxEventLoop swig_types[36]
1471 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
1472 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
1473 #define SWIGTYPE_p_wxFSFile swig_types[39]
1474 #define SWIGTYPE_p_wxFileSystem swig_types[40]
1475 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
1476 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
1477 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
1478 #define SWIGTYPE_p_wxFont swig_types[44]
1479 #define SWIGTYPE_p_wxFrame swig_types[45]
1480 #define SWIGTYPE_p_wxGBPosition swig_types[46]
1481 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
1482 #define SWIGTYPE_p_wxGBSpan swig_types[48]
1483 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
1484 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
1485 #define SWIGTYPE_p_wxGridSizer swig_types[51]
1486 #define SWIGTYPE_p_wxICOHandler swig_types[52]
1487 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
1488 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
1489 #define SWIGTYPE_p_wxImage swig_types[55]
1490 #define SWIGTYPE_p_wxImageHandler swig_types[56]
1491 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
1492 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
1493 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
1494 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
1495 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
1496 #define SWIGTYPE_p_wxInputStream swig_types[62]
1497 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
1498 #define SWIGTYPE_p_wxItemContainer swig_types[64]
1499 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1500 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
1501 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
1502 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
1503 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1504 #define SWIGTYPE_p_wxMenu swig_types[70]
1505 #define SWIGTYPE_p_wxMenuBar swig_types[71]
1506 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
1507 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
1508 #define SWIGTYPE_p_wxMenuItem swig_types[74]
1509 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
1510 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
1511 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
1512 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
1513 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
1514 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
1515 #define SWIGTYPE_p_wxObject swig_types[81]
1516 #define SWIGTYPE_p_wxOutputStream swig_types[82]
1517 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
1518 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
1519 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
1520 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
1521 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
1522 #define SWIGTYPE_p_wxPaperSize swig_types[88]
1523 #define SWIGTYPE_p_wxPoint swig_types[89]
1524 #define SWIGTYPE_p_wxPoint2D swig_types[90]
1525 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
1526 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
1527 #define SWIGTYPE_p_wxPyApp swig_types[93]
1528 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
1529 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
1530 #define SWIGTYPE_p_wxPyEvent swig_types[96]
1531 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
1532 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
1533 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
1534 #define SWIGTYPE_p_wxPySizer swig_types[100]
1535 #define SWIGTYPE_p_wxPyValidator swig_types[101]
1536 #define SWIGTYPE_p_wxQuantize swig_types[102]
1537 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
1538 #define SWIGTYPE_p_wxRealPoint swig_types[104]
1539 #define SWIGTYPE_p_wxRect swig_types[105]
1540 #define SWIGTYPE_p_wxRegion swig_types[106]
1541 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
1542 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
1543 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
1544 #define SWIGTYPE_p_wxShowEvent swig_types[110]
1545 #define SWIGTYPE_p_wxSize swig_types[111]
1546 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
1547 #define SWIGTYPE_p_wxSizer swig_types[113]
1548 #define SWIGTYPE_p_wxSizerItem swig_types[114]
1549 #define SWIGTYPE_p_wxStaticBox swig_types[115]
1550 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
1551 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
1552 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
1553 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
1554 #define SWIGTYPE_p_wxToolTip swig_types[120]
1555 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
1556 #define SWIGTYPE_p_wxValidator swig_types[122]
1557 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
1558 #define SWIGTYPE_p_wxWindow swig_types[124]
1559 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
1560 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
1561 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
1562 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
1563 #define SWIGTYPE_ptrdiff_t swig_types[129]
1564 #define SWIGTYPE_std__ptrdiff_t swig_types[130]
1565 #define SWIGTYPE_unsigned_int swig_types[131]
1566 static swig_type_info *swig_types[133];
1567 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
1568 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1569 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1570
1571 /* -------- TYPES TABLE (END) -------- */
1572
1573
1574 /*-----------------------------------------------
1575 @(target):= _core_.so
1576 ------------------------------------------------*/
1577 #define SWIG_init init_core_
1578
1579 #define SWIG_name "_core_"
1580
1581 #include "wx/wxPython/wxPython_int.h"
1582 #include "wx/wxPython/pyclasses.h"
1583
1584
1585 #ifndef wxPyUSE_EXPORT
1586 // Helper functions for dealing with SWIG objects and such. These are
1587 // located here so they know about the SWIG types and functions declared
1588 // in the wrapper code.
1589
1590 #include <wx/hashmap.h>
1591 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1592
1593
1594 // Maintains a hashmap of className to swig_type_info pointers. Given the
1595 // name of a class either looks up the type info in the cache, or scans the
1596 // SWIG tables for it.
1597 extern PyObject* wxPyPtrTypeMap;
1598 static
1599 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1600
1601 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1602
1603 if (typeInfoCache == NULL)
1604 typeInfoCache = new wxPyTypeInfoHashMap;
1605
1606 wxString name(className);
1607 swig_type_info* swigType = (*typeInfoCache)[name];
1608
1609 if (! swigType) {
1610 // it wasn't in the cache, so look it up from SWIG
1611 name.Append(wxT(" *"));
1612 swigType = SWIG_TypeQuery(name.mb_str());
1613
1614 // if it still wasn't found, try looking for a mapped name
1615 if (!swigType) {
1616 PyObject* item;
1617 name = className;
1618
1619 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1620 (char*)(const char*)name.mbc_str())) != NULL) {
1621 name = wxString(PyString_AsString(item), *wxConvCurrent);
1622 name.Append(wxT(" *"));
1623 swigType = SWIG_TypeQuery(name.mb_str());
1624 }
1625 }
1626 if (swigType) {
1627 // and add it to the map if found
1628 (*typeInfoCache)[className] = swigType;
1629 }
1630 }
1631 return swigType;
1632 }
1633
1634
1635 // Check if a class name is a type known to SWIG
1636 bool wxPyCheckSwigType(const wxChar* className) {
1637
1638 swig_type_info* swigType = wxPyFindSwigType(className);
1639 return swigType != NULL;
1640 }
1641
1642
1643 // Given a pointer to a C++ object and a class name, construct a Python proxy
1644 // object for it.
1645 PyObject* wxPyConstructObject(void* ptr,
1646 const wxChar* className,
1647 int setThisOwn) {
1648
1649 swig_type_info* swigType = wxPyFindSwigType(className);
1650 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1651
1652 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1653 }
1654
1655
1656 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1657 // Ensures that the proxy object is of the specified (or derived) type. If
1658 // not able to perform the conversion then a Python exception is set and the
1659 // error should be handled properly in the caller. Returns True on success.
1660 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1661 const wxChar* className) {
1662
1663 swig_type_info* swigType = wxPyFindSwigType(className);
1664 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1665
1666 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1667 }
1668
1669
1670 // Make a SWIGified pointer object suitable for a .this attribute
1671 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1672
1673 PyObject* robj = NULL;
1674
1675 swig_type_info* swigType = wxPyFindSwigType(className);
1676 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1677
1678 #ifdef SWIG_COBJECT_TYPES
1679 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1680 #else
1681 {
1682 char result[1024];
1683 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1684 PyString_FromString(result) : 0;
1685 }
1686 #endif
1687
1688 return robj;
1689 }
1690
1691
1692 // Python's PyInstance_Check does not return True for instances of new-style
1693 // classes. This should get close enough for both new and old classes but I
1694 // should re-evaluate the need for doing instance checks...
1695 bool wxPyInstance_Check(PyObject* obj) {
1696 return PyObject_HasAttrString(obj, "__class__") != 0;
1697 }
1698
1699
1700
1701 // This one checks if the object is an instance of a SWIG proxy class (it has
1702 // a .this attribute, and the .this attribute is a PySwigObject.)
1703 bool wxPySwigInstance_Check(PyObject* obj) {
1704 static PyObject* this_str = NULL;
1705 if (this_str == NULL)
1706 this_str = PyString_FromString("this");
1707
1708 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1709 if (this_attr) {
1710 bool retval = (PySwigObject_Check(this_attr) != 0);
1711 Py_DECREF(this_attr);
1712 return retval;
1713 }
1714
1715 PyErr_Clear();
1716 return false;
1717 }
1718
1719
1720
1721 // Export a C API in a struct. Other modules will be able to load this from
1722 // the wx._core_ module and will then have safe access to these functions,
1723 // even if they are located in another shared library.
1724 static wxPyCoreAPI API = {
1725
1726 wxPyCheckSwigType,
1727 wxPyConstructObject,
1728 wxPyConvertSwigPtr,
1729 wxPyMakeSwigPtr,
1730
1731 wxPyBeginAllowThreads,
1732 wxPyEndAllowThreads,
1733 wxPyBeginBlockThreads,
1734 wxPyEndBlockThreads,
1735
1736 wxPy_ConvertList,
1737
1738 wxString_in_helper,
1739 Py2wxString,
1740 wx2PyString,
1741
1742 byte_LIST_helper,
1743 int_LIST_helper,
1744 long_LIST_helper,
1745 string_LIST_helper,
1746 wxPoint_LIST_helper,
1747 wxBitmap_LIST_helper,
1748 wxString_LIST_helper,
1749 wxAcceleratorEntry_LIST_helper,
1750
1751 wxSize_helper,
1752 wxPoint_helper,
1753 wxRealPoint_helper,
1754 wxRect_helper,
1755 wxColour_helper,
1756 wxPoint2D_helper,
1757
1758 wxPySimple_typecheck,
1759 wxColour_typecheck,
1760
1761 wxPyCBH_setCallbackInfo,
1762 wxPyCBH_findCallback,
1763 wxPyCBH_callCallback,
1764 wxPyCBH_callCallbackObj,
1765 wxPyCBH_delete,
1766
1767 wxPyMake_wxObject,
1768 wxPyMake_wxSizer,
1769 wxPyPtrTypeMap_Add,
1770 wxPy2int_seq_helper,
1771 wxPy4int_seq_helper,
1772 wxArrayString2PyList_helper,
1773 wxArrayInt2PyList_helper,
1774
1775 wxPyClientData_dtor,
1776 wxPyUserData_dtor,
1777 wxPyOORClientData_dtor,
1778
1779 wxPyCBInputStream_create,
1780 wxPyCBInputStream_copy,
1781
1782 wxPyInstance_Check,
1783 wxPySwigInstance_Check,
1784
1785 wxPyCheckForApp
1786
1787 };
1788
1789 #endif
1790
1791
1792 #if !WXWIN_COMPATIBILITY_2_4
1793 #define wxHIDE_READONLY 0
1794 #endif
1795
1796
1797 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
1798 #define SWIG_From_int PyInt_FromLong
1799 /*@@*/
1800
1801 static const wxString wxPyEmptyString(wxEmptyString);
1802 static wxString wxObject_GetClassName(wxObject *self){
1803 return self->GetClassInfo()->GetClassName();
1804 }
1805 static void wxObject_Destroy(wxObject *self){
1806 delete self;
1807 }
1808
1809 #ifndef __WXMAC__
1810 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1811 #endif
1812
1813
1814 #include <limits.h>
1815
1816
1817 SWIGINTERN int
1818 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1819 const char *errmsg)
1820 {
1821 if (value < min_value) {
1822 if (errmsg) {
1823 PyErr_Format(PyExc_OverflowError,
1824 "value %ld is less than '%s' minimum %ld",
1825 value, errmsg, min_value);
1826 }
1827 return 0;
1828 } else if (value > max_value) {
1829 if (errmsg) {
1830 PyErr_Format(PyExc_OverflowError,
1831 "value %ld is greater than '%s' maximum %ld",
1832 value, errmsg, max_value);
1833 }
1834 return 0;
1835 }
1836 return 1;
1837 }
1838
1839
1840 SWIGINTERN int
1841 SWIG_AsVal_long(PyObject* obj, long* val)
1842 {
1843 if (PyNumber_Check(obj)) {
1844 if (val) *val = PyInt_AsLong(obj);
1845 return 1;
1846 }
1847 else {
1848 SWIG_type_error("number", obj);
1849 }
1850 return 0;
1851 }
1852
1853
1854 #if INT_MAX != LONG_MAX
1855 SWIGINTERN int
1856 SWIG_AsVal_int(PyObject *obj, int *val)
1857 {
1858 const char* errmsg = val ? "int" : (char*)0;
1859 long v;
1860 if (SWIG_AsVal_long(obj, &v)) {
1861 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1862 if (val) *val = static_cast<int >(v);
1863 return 1;
1864 } else {
1865 return 0;
1866 }
1867 } else {
1868 PyErr_Clear();
1869 }
1870 if (val) {
1871 SWIG_type_error(errmsg, obj);
1872 }
1873 return 0;
1874 }
1875 #else
1876 SWIGINTERNINLINE int
1877 SWIG_AsVal_int(PyObject *obj, int *val)
1878 {
1879 return SWIG_AsVal_long(obj,(long*)val);
1880 }
1881 #endif
1882
1883
1884 SWIGINTERNINLINE int
1885 SWIG_As_int(PyObject* obj)
1886 {
1887 int v;
1888 if (!SWIG_AsVal_int(obj, &v)) {
1889 /*
1890 this is needed to make valgrind/purify happier.
1891 */
1892 memset((void*)&v, 0, sizeof(int));
1893 }
1894 return v;
1895 }
1896
1897
1898 SWIGINTERNINLINE int
1899 SWIG_Check_int(PyObject* obj)
1900 {
1901 return SWIG_AsVal_int(obj, (int*)0);
1902 }
1903
1904 static PyObject *wxSize_Get(wxSize *self){
1905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1906 PyObject* tup = PyTuple_New(2);
1907 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1908 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1909 wxPyEndBlockThreads(blocked);
1910 return tup;
1911 }
1912
1913 SWIGINTERN int
1914 SWIG_AsVal_double(PyObject *obj, double* val)
1915 {
1916 if (PyNumber_Check(obj)) {
1917 if (val) *val = PyFloat_AsDouble(obj);
1918 return 1;
1919 }
1920 else {
1921 SWIG_type_error("number", obj);
1922 }
1923 return 0;
1924 }
1925
1926
1927 SWIGINTERNINLINE double
1928 SWIG_As_double(PyObject* obj)
1929 {
1930 double v;
1931 if (!SWIG_AsVal_double(obj, &v)) {
1932 /*
1933 this is needed to make valgrind/purify happier.
1934 */
1935 memset((void*)&v, 0, sizeof(double));
1936 }
1937 return v;
1938 }
1939
1940
1941 SWIGINTERNINLINE int
1942 SWIG_Check_double(PyObject* obj)
1943 {
1944 return SWIG_AsVal_double(obj, (double*)0);
1945 }
1946
1947
1948 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
1949 #define SWIG_From_double PyFloat_FromDouble
1950 /*@@*/
1951
1952 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1953 self->x = x;
1954 self->y = y;
1955 }
1956 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1958 PyObject* tup = PyTuple_New(2);
1959 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1960 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1961 wxPyEndBlockThreads(blocked);
1962 return tup;
1963 }
1964
1965 SWIGINTERNINLINE long
1966 SWIG_As_long(PyObject* obj)
1967 {
1968 long v;
1969 if (!SWIG_AsVal_long(obj, &v)) {
1970 /*
1971 this is needed to make valgrind/purify happier.
1972 */
1973 memset((void*)&v, 0, sizeof(long));
1974 }
1975 return v;
1976 }
1977
1978
1979 SWIGINTERNINLINE int
1980 SWIG_Check_long(PyObject* obj)
1981 {
1982 return SWIG_AsVal_long(obj, (long*)0);
1983 }
1984
1985 static void wxPoint_Set(wxPoint *self,long x,long y){
1986 self->x = x;
1987 self->y = y;
1988 }
1989 static PyObject *wxPoint_Get(wxPoint *self){
1990 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1991 PyObject* tup = PyTuple_New(2);
1992 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1993 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1994 wxPyEndBlockThreads(blocked);
1995 return tup;
1996 }
1997 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1998 self->x = x;
1999 self->y = y;
2000 self->width = width;
2001 self->height = height;
2002 }
2003 static PyObject *wxRect_Get(wxRect *self){
2004 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2005 PyObject* tup = PyTuple_New(4);
2006 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2007 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2008 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2009 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2010 wxPyEndBlockThreads(blocked);
2011 return tup;
2012 }
2013
2014 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2015 wxRegion reg1(*r1);
2016 wxRegion reg2(*r2);
2017 wxRect dest(0,0,0,0);
2018 PyObject* obj;
2019
2020 reg1.Intersect(reg2);
2021 dest = reg1.GetBox();
2022
2023 if (dest != wxRect(0,0,0,0)) {
2024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2025 wxRect* newRect = new wxRect(dest);
2026 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2027 wxPyEndBlockThreads(blocked);
2028 return obj;
2029 }
2030 Py_INCREF(Py_None);
2031 return Py_None;
2032 }
2033
2034
2035 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
2036 PyObject* o2;
2037 PyObject* o3;
2038
2039 if (!target) {
2040 target = o;
2041 } else if (target == Py_None) {
2042 Py_DECREF(Py_None);
2043 target = o;
2044 } else {
2045 if (!PyTuple_Check(target)) {
2046 o2 = target;
2047 target = PyTuple_New(1);
2048 PyTuple_SetItem(target, 0, o2);
2049 }
2050 o3 = PyTuple_New(1);
2051 PyTuple_SetItem(o3, 0, o);
2052
2053 o2 = target;
2054 target = PySequence_Concat(o2, o3);
2055 Py_DECREF(o2);
2056 Py_DECREF(o3);
2057 }
2058 return target;
2059 }
2060
2061
2062 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2063 self->m_x = x;
2064 self->m_y = y;
2065 }
2066 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2068 PyObject* tup = PyTuple_New(2);
2069 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2070 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2071 wxPyEndBlockThreads(blocked);
2072 return tup;
2073 }
2074
2075 #include "wx/wxPython/pyistream.h"
2076
2077 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2078 wxInputStream* wxis = wxPyCBInputStream::create(p);
2079 if (wxis)
2080 return new wxPyInputStream(wxis);
2081 else
2082 return NULL;
2083 }
2084
2085 SWIGINTERNINLINE PyObject*
2086 SWIG_From_char(char c)
2087 {
2088 return PyString_FromStringAndSize(&c,1);
2089 }
2090
2091
2092 SWIGINTERNINLINE PyObject*
2093 SWIG_From_unsigned_SS_long(unsigned long value)
2094 {
2095 return (value > LONG_MAX) ?
2096 PyLong_FromUnsignedLong(value)
2097 : PyInt_FromLong(static_cast<long >(value));
2098 }
2099
2100
2101 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2102 SWIGINTERN int
2103 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2104 {
2105 static swig_type_info* pchar_info = 0;
2106 char* vptr = 0;
2107 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2108 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2109 if (cptr) *cptr = vptr;
2110 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2111 return SWIG_OLDOBJ;
2112 } else {
2113 PyErr_Clear();
2114 if (PyString_Check(obj)) {
2115 if (cptr) {
2116 *cptr = PyString_AS_STRING(obj);
2117 if (psize) {
2118 *psize = PyString_GET_SIZE(obj) + 1;
2119 }
2120 }
2121 return SWIG_PYSTR;
2122 }
2123 }
2124 if (cptr) {
2125 SWIG_type_error("char *", obj);
2126 }
2127 return 0;
2128 }
2129
2130
2131 SWIGINTERN int
2132 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2133 {
2134 char* cptr; size_t csize;
2135 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2136 /* in C you can do:
2137
2138 char x[5] = "hello";
2139
2140 ie, assing the array using an extra '0' char.
2141 */
2142 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2143 if (csize <= size) {
2144 if (val) {
2145 if (csize) memcpy(val, cptr, csize);
2146 if (csize < size) memset(val + csize, 0, size - csize);
2147 }
2148 return 1;
2149 }
2150 }
2151 if (val) {
2152 PyErr_Format(PyExc_TypeError,
2153 "a char array of maximum size %lu is expected",
2154 (unsigned long) size);
2155 }
2156 return 0;
2157 }
2158
2159
2160 SWIGINTERN int
2161 SWIG_AsVal_char(PyObject *obj, char *val)
2162 {
2163 const char* errmsg = val ? "char" : (char*)0;
2164 long v;
2165 if (SWIG_AsVal_long(obj, &v)) {
2166 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2167 if (val) *val = static_cast<char >(v);
2168 return 1;
2169 } else {
2170 return 0;
2171 }
2172 } else {
2173 PyErr_Clear();
2174 return SWIG_AsCharArray(obj, val, 1);
2175 }
2176 }
2177
2178
2179 SWIGINTERNINLINE char
2180 SWIG_As_char(PyObject* obj)
2181 {
2182 char v;
2183 if (!SWIG_AsVal_char(obj, &v)) {
2184 /*
2185 this is needed to make valgrind/purify happier.
2186 */
2187 memset((void*)&v, 0, sizeof(char));
2188 }
2189 return v;
2190 }
2191
2192
2193 SWIGINTERNINLINE int
2194 SWIG_Check_char(PyObject* obj)
2195 {
2196 return SWIG_AsVal_char(obj, (char*)0);
2197 }
2198
2199
2200 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2201 #define SWIG_From_long PyInt_FromLong
2202 /*@@*/
2203
2204 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2205 // We use only strings for the streams, not unicode
2206 PyObject* str = PyObject_Str(obj);
2207 if (! str) {
2208 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2209 return;
2210 }
2211 self->Write(PyString_AS_STRING(str),
2212 PyString_GET_SIZE(str));
2213 Py_DECREF(str);
2214 }
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 class wxPyFileSystemHandler : public wxFileSystemHandler
2220 {
2221 public:
2222 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2223
2224 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2225 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2226 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2227 DEC_PYCALLBACK_STRING__pure(FindNext);
2228
2229 wxString GetProtocol(const wxString& location) {
2230 return wxFileSystemHandler::GetProtocol(location);
2231 }
2232
2233 wxString GetLeftLocation(const wxString& location) {
2234 return wxFileSystemHandler::GetLeftLocation(location);
2235 }
2236
2237 wxString GetAnchor(const wxString& location) {
2238 return wxFileSystemHandler::GetAnchor(location);
2239 }
2240
2241 wxString GetRightLocation(const wxString& location) {
2242 return wxFileSystemHandler::GetRightLocation(location);
2243 }
2244
2245 wxString GetMimeTypeFromExt(const wxString& location) {
2246 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2247 }
2248
2249 PYPRIVATE;
2250 };
2251
2252
2253 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2254 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2255 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2256 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2257
2258
2259 SWIGINTERN int
2260 SWIG_AsVal_bool(PyObject *obj, bool *val)
2261 {
2262 if (obj == Py_True) {
2263 if (val) *val = true;
2264 return 1;
2265 }
2266 if (obj == Py_False) {
2267 if (val) *val = false;
2268 return 1;
2269 }
2270 int res = 0;
2271 if (SWIG_AsVal_int(obj, &res)) {
2272 if (val) *val = res ? true : false;
2273 return 1;
2274 } else {
2275 PyErr_Clear();
2276 }
2277 if (val) {
2278 SWIG_type_error("bool", obj);
2279 }
2280 return 0;
2281 }
2282
2283
2284 SWIGINTERNINLINE bool
2285 SWIG_As_bool(PyObject* obj)
2286 {
2287 bool v;
2288 if (!SWIG_AsVal_bool(obj, &v)) {
2289 /*
2290 this is needed to make valgrind/purify happier.
2291 */
2292 memset((void*)&v, 0, sizeof(bool));
2293 }
2294 return v;
2295 }
2296
2297
2298 SWIGINTERNINLINE int
2299 SWIG_Check_bool(PyObject* obj)
2300 {
2301 return SWIG_AsVal_bool(obj, (bool*)0);
2302 }
2303
2304 static wxString wxFileSystem_URLToFileName(wxString const &url){
2305 wxFileName fname = wxFileSystem::URLToFileName(url);
2306 return fname.GetFullPath();
2307 }
2308
2309 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2310 wxImage& image,
2311 long type) {
2312 wxMemoryFSHandler::AddFile(filename, image, type);
2313 }
2314
2315 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2316 const wxBitmap& bitmap,
2317 long type) {
2318 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2319 }
2320
2321 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2322 PyObject* data) {
2323 if (! PyString_Check(data)) {
2324 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2325 "Expected string object"));
2326 return;
2327 }
2328
2329 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2330 void* ptr = (void*)PyString_AsString(data);
2331 size_t size = PyString_Size(data);
2332 wxPyEndBlockThreads(blocked);
2333
2334 wxMemoryFSHandler::AddFile(filename, ptr, size);
2335 }
2336
2337
2338 #include "wx/wxPython/pyistream.h"
2339
2340
2341 SWIGINTERN int
2342 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2343 {
2344 long v = 0;
2345 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2346 SWIG_type_error("unsigned number", obj);
2347 }
2348 else if (val)
2349 *val = (unsigned long)v;
2350 return 1;
2351 }
2352
2353
2354 SWIGINTERNINLINE int
2355 SWIG_CheckUnsignedLongInRange(unsigned long value,
2356 unsigned long max_value,
2357 const char *errmsg)
2358 {
2359 if (value > max_value) {
2360 if (errmsg) {
2361 PyErr_Format(PyExc_OverflowError,
2362 "value %lu is greater than '%s' minimum %lu",
2363 value, errmsg, max_value);
2364 }
2365 return 0;
2366 }
2367 return 1;
2368 }
2369
2370
2371 SWIGINTERN int
2372 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2373 {
2374 const char* errmsg = val ? "unsigned char" : (char*)0;
2375 unsigned long v;
2376 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2377 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2378 if (val) *val = static_cast<unsigned char >(v);
2379 return 1;
2380 } else {
2381 return 0;
2382 }
2383 } else {
2384 PyErr_Clear();
2385 }
2386 if (val) {
2387 SWIG_type_error(errmsg, obj);
2388 }
2389 return 0;
2390 }
2391
2392
2393 SWIGINTERNINLINE unsigned char
2394 SWIG_As_unsigned_SS_char(PyObject* obj)
2395 {
2396 unsigned char v;
2397 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2398 /*
2399 this is needed to make valgrind/purify happier.
2400 */
2401 memset((void*)&v, 0, sizeof(unsigned char));
2402 }
2403 return v;
2404 }
2405
2406
2407 SWIGINTERNINLINE int
2408 SWIG_Check_unsigned_SS_char(PyObject* obj)
2409 {
2410 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2411 }
2412
2413
2414 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2415 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2416 /*@@*/
2417
2418
2419
2420 SWIGINTERNINLINE unsigned long
2421 SWIG_As_unsigned_SS_long(PyObject* obj)
2422 {
2423 unsigned long v;
2424 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2425 /*
2426 this is needed to make valgrind/purify happier.
2427 */
2428 memset((void*)&v, 0, sizeof(unsigned long));
2429 }
2430 return v;
2431 }
2432
2433
2434 SWIGINTERNINLINE int
2435 SWIG_Check_unsigned_SS_long(PyObject* obj)
2436 {
2437 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2438 }
2439
2440 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2441 wxImageHistogramEntry e = (*self)[key];
2442 return e.value;
2443 }
2444 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2445 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2446 wxImageHistogramEntry e = (*self)[key];
2447 return e.value;
2448 }
2449 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2450 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2451 colour.Green(),
2452 colour.Blue());
2453 wxImageHistogramEntry e = (*self)[key];
2454 return e.value;
2455 }
2456
2457 typedef unsigned char* buffer;
2458
2459
2460 // Pull the nested class out to the top level for SWIG's sake
2461 #define wxImage_RGBValue wxImage::RGBValue
2462 #define wxImage_HSVValue wxImage::HSVValue
2463
2464 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2465 if (width > 0 && height > 0)
2466 return new wxImage(width, height, clear);
2467 else
2468 return new wxImage;
2469 }
2470 static wxImage *new_wxImage(wxBitmap const &bitmap){
2471 return new wxImage(bitmap.ConvertToImage());
2472 }
2473 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2474 if (DATASIZE != width*height*3) {
2475 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2476 return NULL;
2477 }
2478
2479 // Copy the source data so the wxImage can clean it up later
2480 buffer copy = (buffer)malloc(DATASIZE);
2481 if (copy == NULL) {
2482 wxPyBLOCK_THREADS(PyErr_NoMemory());
2483 return NULL;
2484 }
2485 memcpy(copy, data, DATASIZE);
2486 return new wxImage(width, height, copy, false);
2487 }
2488 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2489 if (DATASIZE != width*height*3) {
2490 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2491 return NULL;
2492 }
2493 if (ALPHASIZE != width*height) {
2494 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2495 return NULL;
2496 }
2497
2498 // Copy the source data so the wxImage can clean it up later
2499 buffer dcopy = (buffer)malloc(DATASIZE);
2500 if (dcopy == NULL) {
2501 wxPyBLOCK_THREADS(PyErr_NoMemory());
2502 return NULL;
2503 }
2504 memcpy(dcopy, data, DATASIZE);
2505
2506 buffer acopy = (buffer)malloc(ALPHASIZE);
2507 if (acopy == NULL) {
2508 wxPyBLOCK_THREADS(PyErr_NoMemory());
2509 return NULL;
2510 }
2511 memcpy(acopy, alpha, ALPHASIZE);
2512
2513 return new wxImage(width, height, dcopy, acopy, false);
2514 }
2515 static wxSize wxImage_GetSize(wxImage *self){
2516 wxSize size(self->GetWidth(), self->GetHeight());
2517 return size;
2518 }
2519 static PyObject *wxImage_GetData(wxImage *self){
2520 buffer data = self->GetData();
2521 int len = self->GetWidth() * self->GetHeight() * 3;
2522 PyObject* rv;
2523 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2524 return rv;
2525 }
2526 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2527 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2528 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2529 return;
2530 }
2531 buffer copy = (buffer)malloc(DATASIZE);
2532 if (copy == NULL) {
2533 wxPyBLOCK_THREADS(PyErr_NoMemory());
2534 return;
2535 }
2536 memcpy(copy, data, DATASIZE);
2537 self->SetData(copy, false);
2538 // wxImage takes ownership of copy...
2539 }
2540 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2541 buffer data = self->GetData();
2542 int len = self->GetWidth() * self->GetHeight() * 3;
2543 PyObject* rv;
2544 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2545 return rv;
2546 }
2547 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2548 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2549 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2550 return;
2551 }
2552 self->SetData(data, true);
2553 }
2554 static PyObject *wxImage_GetAlphaData(wxImage *self){
2555 buffer data = self->GetAlpha();
2556 if (! data) {
2557 RETURN_NONE();
2558 } else {
2559 int len = self->GetWidth() * self->GetHeight();
2560 PyObject* rv;
2561 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2562 return rv;
2563 }
2564 }
2565 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2566 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2567 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2568 return;
2569 }
2570 buffer acopy = (buffer)malloc(ALPHASIZE);
2571 if (acopy == NULL) {
2572 wxPyBLOCK_THREADS(PyErr_NoMemory());
2573 return;
2574 }
2575 memcpy(acopy, alpha, ALPHASIZE);
2576 self->SetAlpha(acopy, false);
2577 // wxImage takes ownership of acopy...
2578 }
2579 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2580 buffer data = self->GetAlpha();
2581 int len = self->GetWidth() * self->GetHeight();
2582 PyObject* rv;
2583 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2584 return rv;
2585 }
2586 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2587 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2588 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2589 return;
2590 }
2591 self->SetAlpha(alpha, true);
2592 }
2593 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2594 wxBitmap bitmap(*self, depth);
2595 return bitmap;
2596 }
2597 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2598 wxImage mono = self->ConvertToMono( red, green, blue );
2599 wxBitmap bitmap( mono, 1 );
2600 return bitmap;
2601 }
2602 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2603 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2604 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2605 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2606 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2607 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2608 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2609 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2610 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2611 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2612 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2613 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2614 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2615 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2616 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2617
2618 #include <wx/quantize.h>
2619
2620 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2621 return wxQuantize::Quantize(src, dest,
2622 //NULL, // palette
2623 desiredNoColours,
2624 NULL, // eightBitData
2625 flags);
2626 }
2627 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2628 if (PyCallable_Check(func)) {
2629 self->Connect(id, lastId, eventType,
2630 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2631 new wxPyCallback(func));
2632 }
2633 else if (func == Py_None) {
2634 self->Disconnect(id, lastId, eventType,
2635 (wxObjectEventFunction)
2636 &wxPyCallback::EventThunker);
2637 }
2638 else {
2639 wxPyBLOCK_THREADS(
2640 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2641 }
2642 }
2643 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2644 return self->Disconnect(id, lastId, eventType,
2645 (wxObjectEventFunction)
2646 &wxPyCallback::EventThunker);
2647 }
2648 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2649 if (_self && _self != Py_None) {
2650 self->SetClientObject(new wxPyOORClientData(_self, incref));
2651 }
2652 else {
2653 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2654 if (data) {
2655 self->SetClientObject(NULL); // This will delete it too
2656 }
2657 }
2658 }
2659
2660 #if ! wxUSE_HOTKEY
2661 #define wxEVT_HOTKEY -9999
2662 #endif
2663
2664
2665 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2666 #if wxUSE_UNICODE
2667 return self->GetUnicodeKey();
2668 #else
2669 return 0;
2670 #endif
2671 }
2672
2673 #if UINT_MAX < LONG_MAX
2674 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2675 #define SWIG_From_unsigned_SS_int SWIG_From_long
2676 /*@@*/
2677 #else
2678 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2679 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2680 /*@@*/
2681 #endif
2682
2683
2684 #if UINT_MAX != ULONG_MAX
2685 SWIGINTERN int
2686 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2687 {
2688 const char* errmsg = val ? "unsigned int" : (char*)0;
2689 unsigned long v;
2690 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2691 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2692 if (val) *val = static_cast<unsigned int >(v);
2693 return 1;
2694 }
2695 } else {
2696 PyErr_Clear();
2697 }
2698 if (val) {
2699 SWIG_type_error(errmsg, obj);
2700 }
2701 return 0;
2702 }
2703 #else
2704 SWIGINTERNINLINE unsigned int
2705 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2706 {
2707 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2708 }
2709 #endif
2710
2711
2712 SWIGINTERNINLINE unsigned int
2713 SWIG_As_unsigned_SS_int(PyObject* obj)
2714 {
2715 unsigned int v;
2716 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2717 /*
2718 this is needed to make valgrind/purify happier.
2719 */
2720 memset((void*)&v, 0, sizeof(unsigned int));
2721 }
2722 return v;
2723 }
2724
2725
2726 SWIGINTERNINLINE int
2727 SWIG_Check_unsigned_SS_int(PyObject* obj)
2728 {
2729 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2730 }
2731
2732 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2733 self->m_size = size;
2734 }
2735 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2736 int count = self->GetNumberOfFiles();
2737 wxString* files = self->GetFiles();
2738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2739 PyObject* list = PyList_New(count);
2740
2741 if (!list) {
2742 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2743 wxPyEndBlockThreads(blocked);
2744 return NULL;
2745 }
2746
2747 for (int i=0; i<count; i++) {
2748 PyList_SetItem(list, i, wx2PyString(files[i]));
2749 }
2750 wxPyEndBlockThreads(blocked);
2751 return list;
2752 }
2753
2754
2755 static wxPyApp *new_wxPyApp(){
2756 wxPythonApp = new wxPyApp();
2757 return wxPythonApp;
2758 }
2759
2760 void wxApp_CleanUp() {
2761 __wxPyCleanup();
2762 }
2763
2764
2765 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2766
2767
2768 SWIGINTERNINLINE int
2769 SWIG_AsCharPtr(PyObject *obj, char **val)
2770 {
2771 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2772 return 1;
2773 }
2774 if (val) {
2775 PyErr_Clear();
2776 SWIG_type_error("char *", obj);
2777 }
2778 return 0;
2779 }
2780
2781
2782 SWIGINTERN PyObject *
2783 SWIG_FromCharPtr(const char* cptr)
2784 {
2785 if (cptr) {
2786 size_t size = strlen(cptr);
2787 if (size > INT_MAX) {
2788 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2789 SWIG_TypeQuery("char *"), 0);
2790 } else {
2791 if (size != 0) {
2792 return PyString_FromStringAndSize(cptr, size);
2793 } else {
2794 return PyString_FromString(cptr);
2795 }
2796 }
2797 }
2798 Py_INCREF(Py_None);
2799 return Py_None;
2800 }
2801
2802
2803 #if 0 // #ifdef __WXMAC__
2804
2805 // A dummy class that raises an exception if used...
2806 class wxEventLoop
2807 {
2808 public:
2809 wxEventLoop() { wxPyRaiseNotImplemented(); }
2810 int Run() { return 0; }
2811 void Exit(int rc = 0) {}
2812 bool Pending() const { return false; }
2813 bool Dispatch() { return false; }
2814 bool IsRunning() const { return false; }
2815 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2816 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2817 };
2818
2819 #else
2820
2821 #include <wx/evtloop.h>
2822
2823 #endif
2824
2825
2826
2827 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2828 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2829 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2830 static PyObject *wxWindow_GetChildren(wxWindow *self){
2831 wxWindowList& list = self->GetChildren();
2832 return wxPy_ConvertList(&list);
2833 }
2834 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2835 #if wxUSE_HOTKEY
2836 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2837 #else
2838 return false;
2839 #endif
2840 }
2841 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2842
2843
2844
2845 return false;
2846
2847 }
2848 static long wxWindow_GetHandle(wxWindow *self){
2849 return wxPyGetWinHandle(self);
2850 }
2851 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2852 self->AssociateHandle((WXWidget)handle);
2853 }
2854
2855 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2856 return wxWindow::FindWindowById(id, parent);
2857 }
2858
2859 wxWindow* wxFindWindowByName( const wxString& name,
2860 const wxWindow *parent = NULL ) {
2861 return wxWindow::FindWindowByName(name, parent);
2862 }
2863
2864 wxWindow* wxFindWindowByLabel( const wxString& label,
2865 const wxWindow *parent = NULL ) {
2866 return wxWindow::FindWindowByLabel(label, parent);
2867 }
2868
2869
2870 #ifdef __WXMSW__
2871 #include <wx/msw/private.h> // to get wxGetWindowId
2872 #endif
2873
2874
2875 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2876 #ifdef __WXMSW__
2877 WXHWND hWnd = (WXHWND)_hWnd;
2878 long id = wxGetWindowId(hWnd);
2879 wxWindow* win = new wxWindow;
2880 if (parent)
2881 parent->AddChild(win);
2882 win->SetEventHandler(win);
2883 win->SetHWND(hWnd);
2884 win->SetId(id);
2885 win->SubclassWin(hWnd);
2886 win->AdoptAttributesFromHWND();
2887 win->SetupColours();
2888 return win;
2889 #else
2890 wxPyRaiseNotImplemented();
2891 return NULL;
2892 #endif
2893 }
2894
2895
2896 PyObject* GetTopLevelWindows() {
2897 return wxPy_ConvertList(&wxTopLevelWindows);
2898 }
2899
2900
2901 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2902 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2903 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2904
2905 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2906
2907 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2908 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2909 wxMenuItemList& list = self->GetMenuItems();
2910 return wxPy_ConvertList(&list);
2911 }
2912 static void wxMenuBar_SetAutoWindowMenu(bool enable){}
2913 static bool wxMenuBar_GetAutoWindowMenu(){ return false; }
2914 static const wxString wxPyControlNameStr(wxControlNameStr);
2915 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2916 if (clientData) {
2917 wxPyClientData* data = new wxPyClientData(clientData);
2918 return self->Append(item, data);
2919 } else
2920 return self->Append(item);
2921 }
2922 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2923 if (clientData) {
2924 wxPyClientData* data = new wxPyClientData(clientData);
2925 return self->Insert(item, pos, data);
2926 } else
2927 return self->Insert(item, pos);
2928 }
2929 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2930 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2931 if (data) {
2932 Py_INCREF(data->m_obj);
2933 return data->m_obj;
2934 } else {
2935 Py_INCREF(Py_None);
2936 return Py_None;
2937 }
2938 }
2939 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2940 wxPyClientData* data = new wxPyClientData(clientData);
2941 self->SetClientObject(n, data);
2942 }
2943
2944
2945 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2946 wxPyUserData* data = NULL;
2947 if ( userData ) {
2948 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2949 data = new wxPyUserData(userData);
2950 wxPyEndBlockThreads(blocked);
2951 }
2952 return new wxSizerItem(window, proportion, flag, border, data);
2953 }
2954 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2955 wxPyUserData* data = NULL;
2956 if ( userData ) {
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 data = new wxPyUserData(userData);
2959 wxPyEndBlockThreads(blocked);
2960 }
2961 return new wxSizerItem(width, height, proportion, flag, border, data);
2962 }
2963 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2964 wxPyUserData* data = NULL;
2965 if ( userData ) {
2966 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2967 data = new wxPyUserData(userData);
2968 wxPyEndBlockThreads(blocked);
2969 }
2970 return new wxSizerItem(sizer, proportion, flag, border, data);
2971 }
2972
2973 #include <float.h>
2974 SWIGINTERN int
2975 SWIG_CheckDoubleInRange(double value, double min_value,
2976 double max_value, const char* errmsg)
2977 {
2978 if (value < min_value) {
2979 if (errmsg) {
2980 PyErr_Format(PyExc_OverflowError,
2981 "value %g is less than %s minimum %g",
2982 value, errmsg, min_value);
2983 }
2984 return 0;
2985 } else if (value > max_value) {
2986 if (errmsg) {
2987 PyErr_Format(PyExc_OverflowError,
2988 "value %g is greater than %s maximum %g",
2989 value, errmsg, max_value);
2990 }
2991 return 0;
2992 }
2993 return 1;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float(PyObject *obj, float *val)
2999 {
3000 const char* errmsg = val ? "float" : (char*)0;
3001 double v;
3002 if (SWIG_AsVal_double(obj, &v)) {
3003 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3004 if (val) *val = static_cast<float >(v);
3005 return 1;
3006 } else {
3007 return 0;
3008 }
3009 } else {
3010 PyErr_Clear();
3011 }
3012 if (val) {
3013 SWIG_type_error(errmsg, obj);
3014 }
3015 return 0;
3016 }
3017
3018
3019 SWIGINTERNINLINE float
3020 SWIG_As_float(PyObject* obj)
3021 {
3022 float v;
3023 if (!SWIG_AsVal_float(obj, &v)) {
3024 /*
3025 this is needed to make valgrind/purify happier.
3026 */
3027 memset((void*)&v, 0, sizeof(float));
3028 }
3029 return v;
3030 }
3031
3032
3033 SWIGINTERNINLINE int
3034 SWIG_Check_float(PyObject* obj)
3035 {
3036 return SWIG_AsVal_float(obj, (float*)0);
3037 }
3038
3039
3040 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
3041 #define SWIG_From_float PyFloat_FromDouble
3042 /*@@*/
3043
3044 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3045 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3046 if (data) {
3047 Py_INCREF(data->m_obj);
3048 return data->m_obj;
3049 } else {
3050 Py_INCREF(Py_None);
3051 return Py_None;
3052 }
3053 }
3054 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3055 wxPyUserData* data = NULL;
3056 if ( userData ) {
3057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 data = new wxPyUserData(userData);
3059 wxPyEndBlockThreads(blocked);
3060 }
3061 self->SetUserData(data);
3062 }
3063
3064 // Figure out the type of the sizer item
3065
3066 struct wxPySizerItemInfo {
3067 wxPySizerItemInfo()
3068 : window(NULL), sizer(NULL), gotSize(false),
3069 size(wxDefaultSize), gotPos(false), pos(-1)
3070 {}
3071
3072 wxWindow* window;
3073 wxSizer* sizer;
3074 bool gotSize;
3075 wxSize size;
3076 bool gotPos;
3077 int pos;
3078 };
3079
3080 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3081
3082 wxPySizerItemInfo info;
3083 wxSize size;
3084 wxSize* sizePtr = &size;
3085
3086 // Find out what the type of the item is
3087 // try wxWindow
3088 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3089 PyErr_Clear();
3090 info.window = NULL;
3091
3092 // try wxSizer
3093 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3094 PyErr_Clear();
3095 info.sizer = NULL;
3096
3097 // try wxSize or (w,h)
3098 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3099 info.size = *sizePtr;
3100 info.gotSize = true;
3101 }
3102
3103 // or a single int
3104 if (checkIdx && PyInt_Check(item)) {
3105 info.pos = PyInt_AsLong(item);
3106 info.gotPos = true;
3107 }
3108 }
3109 }
3110
3111 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3112 // no expected type, figure out what kind of error message to generate
3113 if ( !checkSize && !checkIdx )
3114 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3115 else if ( checkSize && !checkIdx )
3116 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3117 else if ( !checkSize && checkIdx)
3118 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3119 else
3120 // can this one happen?
3121 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3122 }
3123
3124 return info;
3125 }
3126
3127 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3128 if (!self->GetClientObject())
3129 self->SetClientObject(new wxPyOORClientData(_self));
3130 }
3131 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3132
3133 wxPyUserData* data = NULL;
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3136 if ( userData && (info.window || info.sizer || info.gotSize) )
3137 data = new wxPyUserData(userData);
3138 wxPyEndBlockThreads(blocked);
3139
3140 // Now call the real Add method if a valid item type was found
3141 if ( info.window )
3142 return self->Add(info.window, proportion, flag, border, data);
3143 else if ( info.sizer )
3144 return self->Add(info.sizer, proportion, flag, border, data);
3145 else if (info.gotSize)
3146 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3147 proportion, flag, border, data);
3148 else
3149 return NULL;
3150 }
3151 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3152
3153 wxPyUserData* data = NULL;
3154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3156 if ( userData && (info.window || info.sizer || info.gotSize) )
3157 data = new wxPyUserData(userData);
3158 wxPyEndBlockThreads(blocked);
3159
3160 // Now call the real Insert method if a valid item type was found
3161 if ( info.window )
3162 return self->Insert(before, info.window, proportion, flag, border, data);
3163 else if ( info.sizer )
3164 return self->Insert(before, info.sizer, proportion, flag, border, data);
3165 else if (info.gotSize)
3166 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3167 proportion, flag, border, data);
3168 else
3169 return NULL;
3170 }
3171 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3172
3173 wxPyUserData* data = NULL;
3174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3176 if ( userData && (info.window || info.sizer || info.gotSize) )
3177 data = new wxPyUserData(userData);
3178 wxPyEndBlockThreads(blocked);
3179
3180 // Now call the real Prepend method if a valid item type was found
3181 if ( info.window )
3182 return self->Prepend(info.window, proportion, flag, border, data);
3183 else if ( info.sizer )
3184 return self->Prepend(info.sizer, proportion, flag, border, data);
3185 else if (info.gotSize)
3186 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3187 proportion, flag, border, data);
3188 else
3189 return NULL;
3190 }
3191 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3194 wxPyEndBlockThreads(blocked);
3195 if ( info.window )
3196 return self->Remove(info.window);
3197 else if ( info.sizer )
3198 return self->Remove(info.sizer);
3199 else if ( info.gotPos )
3200 return self->Remove(info.pos);
3201 else
3202 return false;
3203 }
3204 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3205 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3206 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3207 wxPyEndBlockThreads(blocked);
3208 if ( info.window )
3209 return self->Detach(info.window);
3210 else if ( info.sizer )
3211 return self->Detach(info.sizer);
3212 else if ( info.gotPos )
3213 return self->Detach(info.pos);
3214 else
3215 return false;
3216 }
3217 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3218 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3219 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3220 wxPyEndBlockThreads(blocked);
3221 if ( info.window )
3222 return self->GetItem(info.window);
3223 else if ( info.sizer )
3224 return self->GetItem(info.sizer);
3225 else if ( info.gotPos )
3226 return self->GetItem(info.pos);
3227 else
3228 return NULL;
3229 }
3230 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3231 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3232 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3233 wxPyEndBlockThreads(blocked);
3234 if ( info.window )
3235 self->SetItemMinSize(info.window, size);
3236 else if ( info.sizer )
3237 self->SetItemMinSize(info.sizer, size);
3238 else if ( info.gotPos )
3239 self->SetItemMinSize(info.pos, size);
3240 }
3241 static PyObject *wxSizer_GetChildren(wxSizer *self){
3242 wxSizerItemList& list = self->GetChildren();
3243 return wxPy_ConvertList(&list);
3244 }
3245 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3248 wxPyEndBlockThreads(blocked);
3249 if ( info.window )
3250 return self->Show(info.window, show, recursive);
3251 else if ( info.sizer )
3252 return self->Show(info.sizer, show, recursive);
3253 else if ( info.gotPos )
3254 return self->Show(info.pos, show);
3255 else
3256 return false;
3257 }
3258 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3259 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3260 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3261 wxPyEndBlockThreads(blocked);
3262 if ( info.window )
3263 return self->IsShown(info.window);
3264 else if ( info.sizer )
3265 return self->IsShown(info.sizer);
3266 else if ( info.gotPos )
3267 return self->IsShown(info.pos);
3268 else
3269 return false;
3270 }
3271
3272 // See pyclasses.h
3273 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3274 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3275 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3276
3277
3278
3279
3280 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3281 {
3282 if (source == Py_None) {
3283 **obj = wxGBPosition(-1,-1);
3284 return true;
3285 }
3286 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3287 }
3288
3289 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3290 {
3291 if (source == Py_None) {
3292 **obj = wxGBSpan(-1,-1);
3293 return true;
3294 }
3295 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3296 }
3297
3298
3299 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3300 self->SetRow(row);
3301 self->SetCol(col);
3302 }
3303 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3305 PyObject* tup = PyTuple_New(2);
3306 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3307 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3308 wxPyEndBlockThreads(blocked);
3309 return tup;
3310 }
3311 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3312 self->SetRowspan(rowspan);
3313 self->SetColspan(colspan);
3314 }
3315 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3317 PyObject* tup = PyTuple_New(2);
3318 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3319 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3320 wxPyEndBlockThreads(blocked);
3321 return tup;
3322 }
3323 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3324 wxPyUserData* data = NULL;
3325 if ( userData ) {
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 data = new wxPyUserData(userData);
3328 wxPyEndBlockThreads(blocked);
3329 }
3330 return new wxGBSizerItem(window, pos, span, flag, border, data);
3331 }
3332 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
3340 }
3341 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,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(width, height, pos, span, flag, border, data);
3349 }
3350 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3351 int row, col;
3352 self->GetEndPos(row, col);
3353 return wxGBPosition(row, col);
3354 }
3355 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3356
3357 wxPyUserData* data = NULL;
3358 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3359 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3360 if ( userData && (info.window || info.sizer || info.gotSize) )
3361 data = new wxPyUserData(userData);
3362 wxPyEndBlockThreads(blocked);
3363
3364 // Now call the real Add method if a valid item type was found
3365 if ( info.window )
3366 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3367 else if ( info.sizer )
3368 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3369 else if (info.gotSize)
3370 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3371 pos, span, flag, border, data);
3372 return NULL;
3373 }
3374
3375
3376 #ifdef __cplusplus
3377 extern "C" {
3378 #endif
3379 static int _wrap_EmptyString_set(PyObject *) {
3380 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3381 return 1;
3382 }
3383
3384
3385 static PyObject *_wrap_EmptyString_get(void) {
3386 PyObject *pyobj = NULL;
3387
3388 {
3389 #if wxUSE_UNICODE
3390 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3391 #else
3392 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3393 #endif
3394 }
3395 return pyobj;
3396 }
3397
3398
3399 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj = NULL;
3401 wxObject *arg1 = (wxObject *) 0 ;
3402 wxString result;
3403 PyObject * obj0 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "self", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3410 if (SWIG_arg_fail(1)) SWIG_fail;
3411 {
3412 PyThreadState* __tstate = wxPyBeginAllowThreads();
3413 result = wxObject_GetClassName(arg1);
3414
3415 wxPyEndAllowThreads(__tstate);
3416 if (PyErr_Occurred()) SWIG_fail;
3417 }
3418 {
3419 #if wxUSE_UNICODE
3420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3421 #else
3422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3423 #endif
3424 }
3425 return resultobj;
3426 fail:
3427 return NULL;
3428 }
3429
3430
3431 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3432 PyObject *resultobj = NULL;
3433 wxObject *arg1 = (wxObject *) 0 ;
3434 PyObject * obj0 = 0 ;
3435 char *kwnames[] = {
3436 (char *) "self", NULL
3437 };
3438
3439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3441 if (SWIG_arg_fail(1)) SWIG_fail;
3442 {
3443 PyThreadState* __tstate = wxPyBeginAllowThreads();
3444 wxObject_Destroy(arg1);
3445
3446 wxPyEndAllowThreads(__tstate);
3447 if (PyErr_Occurred()) SWIG_fail;
3448 }
3449 Py_INCREF(Py_None); resultobj = Py_None;
3450 return resultobj;
3451 fail:
3452 return NULL;
3453 }
3454
3455
3456 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3457 PyObject *obj;
3458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3459 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3460 Py_INCREF(obj);
3461 return Py_BuildValue((char *)"");
3462 }
3463 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3464 PyObject *resultobj = NULL;
3465 wxSize *arg1 = (wxSize *) 0 ;
3466 int arg2 ;
3467 PyObject * obj0 = 0 ;
3468 PyObject * obj1 = 0 ;
3469 char *kwnames[] = {
3470 (char *) "self",(char *) "x", NULL
3471 };
3472
3473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3475 if (SWIG_arg_fail(1)) SWIG_fail;
3476 {
3477 arg2 = static_cast<int >(SWIG_As_int(obj1));
3478 if (SWIG_arg_fail(2)) SWIG_fail;
3479 }
3480 if (arg1) (arg1)->x = arg2;
3481
3482 Py_INCREF(Py_None); resultobj = Py_None;
3483 return resultobj;
3484 fail:
3485 return NULL;
3486 }
3487
3488
3489 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj = NULL;
3491 wxSize *arg1 = (wxSize *) 0 ;
3492 int result;
3493 PyObject * obj0 = 0 ;
3494 char *kwnames[] = {
3495 (char *) "self", NULL
3496 };
3497
3498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3500 if (SWIG_arg_fail(1)) SWIG_fail;
3501 result = (int) ((arg1)->x);
3502
3503 {
3504 resultobj = SWIG_From_int(static_cast<int >(result));
3505 }
3506 return resultobj;
3507 fail:
3508 return NULL;
3509 }
3510
3511
3512 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3513 PyObject *resultobj = NULL;
3514 wxSize *arg1 = (wxSize *) 0 ;
3515 int arg2 ;
3516 PyObject * obj0 = 0 ;
3517 PyObject * obj1 = 0 ;
3518 char *kwnames[] = {
3519 (char *) "self",(char *) "y", NULL
3520 };
3521
3522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3524 if (SWIG_arg_fail(1)) SWIG_fail;
3525 {
3526 arg2 = static_cast<int >(SWIG_As_int(obj1));
3527 if (SWIG_arg_fail(2)) SWIG_fail;
3528 }
3529 if (arg1) (arg1)->y = arg2;
3530
3531 Py_INCREF(Py_None); resultobj = Py_None;
3532 return resultobj;
3533 fail:
3534 return NULL;
3535 }
3536
3537
3538 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3539 PyObject *resultobj = NULL;
3540 wxSize *arg1 = (wxSize *) 0 ;
3541 int result;
3542 PyObject * obj0 = 0 ;
3543 char *kwnames[] = {
3544 (char *) "self", NULL
3545 };
3546
3547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3549 if (SWIG_arg_fail(1)) SWIG_fail;
3550 result = (int) ((arg1)->y);
3551
3552 {
3553 resultobj = SWIG_From_int(static_cast<int >(result));
3554 }
3555 return resultobj;
3556 fail:
3557 return NULL;
3558 }
3559
3560
3561 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3562 PyObject *resultobj = NULL;
3563 int arg1 = (int) 0 ;
3564 int arg2 = (int) 0 ;
3565 wxSize *result;
3566 PyObject * obj0 = 0 ;
3567 PyObject * obj1 = 0 ;
3568 char *kwnames[] = {
3569 (char *) "w",(char *) "h", NULL
3570 };
3571
3572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3573 if (obj0) {
3574 {
3575 arg1 = static_cast<int >(SWIG_As_int(obj0));
3576 if (SWIG_arg_fail(1)) SWIG_fail;
3577 }
3578 }
3579 if (obj1) {
3580 {
3581 arg2 = static_cast<int >(SWIG_As_int(obj1));
3582 if (SWIG_arg_fail(2)) SWIG_fail;
3583 }
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 result = (wxSize *)new wxSize(arg1,arg2);
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3593 return resultobj;
3594 fail:
3595 return NULL;
3596 }
3597
3598
3599 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3600 PyObject *resultobj = NULL;
3601 wxSize *arg1 = (wxSize *) 0 ;
3602 PyObject * obj0 = 0 ;
3603 char *kwnames[] = {
3604 (char *) "self", NULL
3605 };
3606
3607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3609 if (SWIG_arg_fail(1)) SWIG_fail;
3610 {
3611 PyThreadState* __tstate = wxPyBeginAllowThreads();
3612 delete arg1;
3613
3614 wxPyEndAllowThreads(__tstate);
3615 if (PyErr_Occurred()) SWIG_fail;
3616 }
3617 Py_INCREF(Py_None); resultobj = Py_None;
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj = NULL;
3626 wxSize *arg1 = (wxSize *) 0 ;
3627 wxSize *arg2 = 0 ;
3628 bool result;
3629 wxSize temp2 ;
3630 PyObject * obj0 = 0 ;
3631 PyObject * obj1 = 0 ;
3632 char *kwnames[] = {
3633 (char *) "self",(char *) "sz", NULL
3634 };
3635
3636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3638 if (SWIG_arg_fail(1)) SWIG_fail;
3639 {
3640 arg2 = &temp2;
3641 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3642 }
3643 {
3644 PyThreadState* __tstate = wxPyBeginAllowThreads();
3645 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3646
3647 wxPyEndAllowThreads(__tstate);
3648 if (PyErr_Occurred()) SWIG_fail;
3649 }
3650 {
3651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3652 }
3653 return resultobj;
3654 fail:
3655 return NULL;
3656 }
3657
3658
3659 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3660 PyObject *resultobj = NULL;
3661 wxSize *arg1 = (wxSize *) 0 ;
3662 wxSize *arg2 = 0 ;
3663 bool result;
3664 wxSize temp2 ;
3665 PyObject * obj0 = 0 ;
3666 PyObject * obj1 = 0 ;
3667 char *kwnames[] = {
3668 (char *) "self",(char *) "sz", NULL
3669 };
3670
3671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 {
3675 arg2 = &temp2;
3676 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3677 }
3678 {
3679 PyThreadState* __tstate = wxPyBeginAllowThreads();
3680 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3681
3682 wxPyEndAllowThreads(__tstate);
3683 if (PyErr_Occurred()) SWIG_fail;
3684 }
3685 {
3686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3687 }
3688 return resultobj;
3689 fail:
3690 return NULL;
3691 }
3692
3693
3694 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3695 PyObject *resultobj = NULL;
3696 wxSize *arg1 = (wxSize *) 0 ;
3697 wxSize *arg2 = 0 ;
3698 wxSize result;
3699 wxSize temp2 ;
3700 PyObject * obj0 = 0 ;
3701 PyObject * obj1 = 0 ;
3702 char *kwnames[] = {
3703 (char *) "self",(char *) "sz", NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3708 if (SWIG_arg_fail(1)) SWIG_fail;
3709 {
3710 arg2 = &temp2;
3711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3712 }
3713 {
3714 PyThreadState* __tstate = wxPyBeginAllowThreads();
3715 result = (arg1)->operator +((wxSize const &)*arg2);
3716
3717 wxPyEndAllowThreads(__tstate);
3718 if (PyErr_Occurred()) SWIG_fail;
3719 }
3720 {
3721 wxSize * resultptr;
3722 resultptr = new wxSize(static_cast<wxSize & >(result));
3723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3724 }
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj = NULL;
3733 wxSize *arg1 = (wxSize *) 0 ;
3734 wxSize *arg2 = 0 ;
3735 wxSize result;
3736 wxSize temp2 ;
3737 PyObject * obj0 = 0 ;
3738 PyObject * obj1 = 0 ;
3739 char *kwnames[] = {
3740 (char *) "self",(char *) "sz", NULL
3741 };
3742
3743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3745 if (SWIG_arg_fail(1)) SWIG_fail;
3746 {
3747 arg2 = &temp2;
3748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3749 }
3750 {
3751 PyThreadState* __tstate = wxPyBeginAllowThreads();
3752 result = (arg1)->operator -((wxSize const &)*arg2);
3753
3754 wxPyEndAllowThreads(__tstate);
3755 if (PyErr_Occurred()) SWIG_fail;
3756 }
3757 {
3758 wxSize * resultptr;
3759 resultptr = new wxSize(static_cast<wxSize & >(result));
3760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3761 }
3762 return resultobj;
3763 fail:
3764 return NULL;
3765 }
3766
3767
3768 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3769 PyObject *resultobj = NULL;
3770 wxSize *arg1 = (wxSize *) 0 ;
3771 wxSize *arg2 = 0 ;
3772 wxSize temp2 ;
3773 PyObject * obj0 = 0 ;
3774 PyObject * obj1 = 0 ;
3775 char *kwnames[] = {
3776 (char *) "self",(char *) "sz", NULL
3777 };
3778
3779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3781 if (SWIG_arg_fail(1)) SWIG_fail;
3782 {
3783 arg2 = &temp2;
3784 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3785 }
3786 {
3787 PyThreadState* __tstate = wxPyBeginAllowThreads();
3788 (arg1)->IncTo((wxSize const &)*arg2);
3789
3790 wxPyEndAllowThreads(__tstate);
3791 if (PyErr_Occurred()) SWIG_fail;
3792 }
3793 Py_INCREF(Py_None); resultobj = Py_None;
3794 return resultobj;
3795 fail:
3796 return NULL;
3797 }
3798
3799
3800 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3801 PyObject *resultobj = NULL;
3802 wxSize *arg1 = (wxSize *) 0 ;
3803 wxSize *arg2 = 0 ;
3804 wxSize temp2 ;
3805 PyObject * obj0 = 0 ;
3806 PyObject * obj1 = 0 ;
3807 char *kwnames[] = {
3808 (char *) "self",(char *) "sz", NULL
3809 };
3810
3811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3813 if (SWIG_arg_fail(1)) SWIG_fail;
3814 {
3815 arg2 = &temp2;
3816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3817 }
3818 {
3819 PyThreadState* __tstate = wxPyBeginAllowThreads();
3820 (arg1)->DecTo((wxSize const &)*arg2);
3821
3822 wxPyEndAllowThreads(__tstate);
3823 if (PyErr_Occurred()) SWIG_fail;
3824 }
3825 Py_INCREF(Py_None); resultobj = Py_None;
3826 return resultobj;
3827 fail:
3828 return NULL;
3829 }
3830
3831
3832 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3833 PyObject *resultobj = NULL;
3834 wxSize *arg1 = (wxSize *) 0 ;
3835 int arg2 ;
3836 int arg3 ;
3837 PyObject * obj0 = 0 ;
3838 PyObject * obj1 = 0 ;
3839 PyObject * obj2 = 0 ;
3840 char *kwnames[] = {
3841 (char *) "self",(char *) "w",(char *) "h", NULL
3842 };
3843
3844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3846 if (SWIG_arg_fail(1)) SWIG_fail;
3847 {
3848 arg2 = static_cast<int >(SWIG_As_int(obj1));
3849 if (SWIG_arg_fail(2)) SWIG_fail;
3850 }
3851 {
3852 arg3 = static_cast<int >(SWIG_As_int(obj2));
3853 if (SWIG_arg_fail(3)) SWIG_fail;
3854 }
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 (arg1)->Set(arg2,arg3);
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 Py_INCREF(Py_None); resultobj = Py_None;
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj = NULL;
3871 wxSize *arg1 = (wxSize *) 0 ;
3872 int arg2 ;
3873 PyObject * obj0 = 0 ;
3874 PyObject * obj1 = 0 ;
3875 char *kwnames[] = {
3876 (char *) "self",(char *) "w", NULL
3877 };
3878
3879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3881 if (SWIG_arg_fail(1)) SWIG_fail;
3882 {
3883 arg2 = static_cast<int >(SWIG_As_int(obj1));
3884 if (SWIG_arg_fail(2)) SWIG_fail;
3885 }
3886 {
3887 PyThreadState* __tstate = wxPyBeginAllowThreads();
3888 (arg1)->SetWidth(arg2);
3889
3890 wxPyEndAllowThreads(__tstate);
3891 if (PyErr_Occurred()) SWIG_fail;
3892 }
3893 Py_INCREF(Py_None); resultobj = Py_None;
3894 return resultobj;
3895 fail:
3896 return NULL;
3897 }
3898
3899
3900 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3901 PyObject *resultobj = NULL;
3902 wxSize *arg1 = (wxSize *) 0 ;
3903 int arg2 ;
3904 PyObject * obj0 = 0 ;
3905 PyObject * obj1 = 0 ;
3906 char *kwnames[] = {
3907 (char *) "self",(char *) "h", NULL
3908 };
3909
3910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3912 if (SWIG_arg_fail(1)) SWIG_fail;
3913 {
3914 arg2 = static_cast<int >(SWIG_As_int(obj1));
3915 if (SWIG_arg_fail(2)) SWIG_fail;
3916 }
3917 {
3918 PyThreadState* __tstate = wxPyBeginAllowThreads();
3919 (arg1)->SetHeight(arg2);
3920
3921 wxPyEndAllowThreads(__tstate);
3922 if (PyErr_Occurred()) SWIG_fail;
3923 }
3924 Py_INCREF(Py_None); resultobj = Py_None;
3925 return resultobj;
3926 fail:
3927 return NULL;
3928 }
3929
3930
3931 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3932 PyObject *resultobj = NULL;
3933 wxSize *arg1 = (wxSize *) 0 ;
3934 int result;
3935 PyObject * obj0 = 0 ;
3936 char *kwnames[] = {
3937 (char *) "self", NULL
3938 };
3939
3940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3942 if (SWIG_arg_fail(1)) SWIG_fail;
3943 {
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 result = (int)((wxSize const *)arg1)->GetWidth();
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 {
3951 resultobj = SWIG_From_int(static_cast<int >(result));
3952 }
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj = NULL;
3961 wxSize *arg1 = (wxSize *) 0 ;
3962 int result;
3963 PyObject * obj0 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 result = (int)((wxSize const *)arg1)->GetHeight();
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 {
3979 resultobj = SWIG_From_int(static_cast<int >(result));
3980 }
3981 return resultobj;
3982 fail:
3983 return NULL;
3984 }
3985
3986
3987 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj = NULL;
3989 wxSize *arg1 = (wxSize *) 0 ;
3990 bool result;
3991 PyObject * obj0 = 0 ;
3992 char *kwnames[] = {
3993 (char *) "self", NULL
3994 };
3995
3996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3998 if (SWIG_arg_fail(1)) SWIG_fail;
3999 {
4000 PyThreadState* __tstate = wxPyBeginAllowThreads();
4001 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4002
4003 wxPyEndAllowThreads(__tstate);
4004 if (PyErr_Occurred()) SWIG_fail;
4005 }
4006 {
4007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4008 }
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj = NULL;
4017 wxSize *arg1 = (wxSize *) 0 ;
4018 wxSize *arg2 = 0 ;
4019 wxSize temp2 ;
4020 PyObject * obj0 = 0 ;
4021 PyObject * obj1 = 0 ;
4022 char *kwnames[] = {
4023 (char *) "self",(char *) "size", NULL
4024 };
4025
4026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4028 if (SWIG_arg_fail(1)) SWIG_fail;
4029 {
4030 arg2 = &temp2;
4031 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4032 }
4033 {
4034 PyThreadState* __tstate = wxPyBeginAllowThreads();
4035 (arg1)->SetDefaults((wxSize const &)*arg2);
4036
4037 wxPyEndAllowThreads(__tstate);
4038 if (PyErr_Occurred()) SWIG_fail;
4039 }
4040 Py_INCREF(Py_None); resultobj = Py_None;
4041 return resultobj;
4042 fail:
4043 return NULL;
4044 }
4045
4046
4047 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4048 PyObject *resultobj = NULL;
4049 wxSize *arg1 = (wxSize *) 0 ;
4050 PyObject *result;
4051 PyObject * obj0 = 0 ;
4052 char *kwnames[] = {
4053 (char *) "self", NULL
4054 };
4055
4056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4058 if (SWIG_arg_fail(1)) SWIG_fail;
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 result = (PyObject *)wxSize_Get(arg1);
4062
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 resultobj = result;
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4074 PyObject *obj;
4075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4076 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4077 Py_INCREF(obj);
4078 return Py_BuildValue((char *)"");
4079 }
4080 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4081 PyObject *resultobj = NULL;
4082 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4083 double arg2 ;
4084 PyObject * obj0 = 0 ;
4085 PyObject * obj1 = 0 ;
4086 char *kwnames[] = {
4087 (char *) "self",(char *) "x", NULL
4088 };
4089
4090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4092 if (SWIG_arg_fail(1)) SWIG_fail;
4093 {
4094 arg2 = static_cast<double >(SWIG_As_double(obj1));
4095 if (SWIG_arg_fail(2)) SWIG_fail;
4096 }
4097 if (arg1) (arg1)->x = arg2;
4098
4099 Py_INCREF(Py_None); resultobj = Py_None;
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj = NULL;
4108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4109 double result;
4110 PyObject * obj0 = 0 ;
4111 char *kwnames[] = {
4112 (char *) "self", NULL
4113 };
4114
4115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 result = (double) ((arg1)->x);
4119
4120 {
4121 resultobj = SWIG_From_double(static_cast<double >(result));
4122 }
4123 return resultobj;
4124 fail:
4125 return NULL;
4126 }
4127
4128
4129 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4130 PyObject *resultobj = NULL;
4131 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4132 double arg2 ;
4133 PyObject * obj0 = 0 ;
4134 PyObject * obj1 = 0 ;
4135 char *kwnames[] = {
4136 (char *) "self",(char *) "y", NULL
4137 };
4138
4139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4141 if (SWIG_arg_fail(1)) SWIG_fail;
4142 {
4143 arg2 = static_cast<double >(SWIG_As_double(obj1));
4144 if (SWIG_arg_fail(2)) SWIG_fail;
4145 }
4146 if (arg1) (arg1)->y = arg2;
4147
4148 Py_INCREF(Py_None); resultobj = Py_None;
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj = NULL;
4157 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4158 double result;
4159 PyObject * obj0 = 0 ;
4160 char *kwnames[] = {
4161 (char *) "self", NULL
4162 };
4163
4164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4166 if (SWIG_arg_fail(1)) SWIG_fail;
4167 result = (double) ((arg1)->y);
4168
4169 {
4170 resultobj = SWIG_From_double(static_cast<double >(result));
4171 }
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj = NULL;
4180 double arg1 = (double) 0.0 ;
4181 double arg2 = (double) 0.0 ;
4182 wxRealPoint *result;
4183 PyObject * obj0 = 0 ;
4184 PyObject * obj1 = 0 ;
4185 char *kwnames[] = {
4186 (char *) "x",(char *) "y", NULL
4187 };
4188
4189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4190 if (obj0) {
4191 {
4192 arg1 = static_cast<double >(SWIG_As_double(obj0));
4193 if (SWIG_arg_fail(1)) SWIG_fail;
4194 }
4195 }
4196 if (obj1) {
4197 {
4198 arg2 = static_cast<double >(SWIG_As_double(obj1));
4199 if (SWIG_arg_fail(2)) SWIG_fail;
4200 }
4201 }
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4205
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj = NULL;
4218 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4219 PyObject * obj0 = 0 ;
4220 char *kwnames[] = {
4221 (char *) "self", NULL
4222 };
4223
4224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4226 if (SWIG_arg_fail(1)) SWIG_fail;
4227 {
4228 PyThreadState* __tstate = wxPyBeginAllowThreads();
4229 delete arg1;
4230
4231 wxPyEndAllowThreads(__tstate);
4232 if (PyErr_Occurred()) SWIG_fail;
4233 }
4234 Py_INCREF(Py_None); resultobj = Py_None;
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj = NULL;
4243 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4244 wxRealPoint *arg2 = 0 ;
4245 bool result;
4246 wxRealPoint temp2 ;
4247 PyObject * obj0 = 0 ;
4248 PyObject * obj1 = 0 ;
4249 char *kwnames[] = {
4250 (char *) "self",(char *) "pt", NULL
4251 };
4252
4253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4255 if (SWIG_arg_fail(1)) SWIG_fail;
4256 {
4257 arg2 = &temp2;
4258 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4259 }
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 {
4268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4269 }
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4277 PyObject *resultobj = NULL;
4278 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4279 wxRealPoint *arg2 = 0 ;
4280 bool result;
4281 wxRealPoint temp2 ;
4282 PyObject * obj0 = 0 ;
4283 PyObject * obj1 = 0 ;
4284 char *kwnames[] = {
4285 (char *) "self",(char *) "pt", NULL
4286 };
4287
4288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4290 if (SWIG_arg_fail(1)) SWIG_fail;
4291 {
4292 arg2 = &temp2;
4293 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4294 }
4295 {
4296 PyThreadState* __tstate = wxPyBeginAllowThreads();
4297 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4298
4299 wxPyEndAllowThreads(__tstate);
4300 if (PyErr_Occurred()) SWIG_fail;
4301 }
4302 {
4303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4304 }
4305 return resultobj;
4306 fail:
4307 return NULL;
4308 }
4309
4310
4311 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj = NULL;
4313 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4314 wxRealPoint *arg2 = 0 ;
4315 wxRealPoint result;
4316 wxRealPoint temp2 ;
4317 PyObject * obj0 = 0 ;
4318 PyObject * obj1 = 0 ;
4319 char *kwnames[] = {
4320 (char *) "self",(char *) "pt", NULL
4321 };
4322
4323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4325 if (SWIG_arg_fail(1)) SWIG_fail;
4326 {
4327 arg2 = &temp2;
4328 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4329 }
4330 {
4331 PyThreadState* __tstate = wxPyBeginAllowThreads();
4332 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4333
4334 wxPyEndAllowThreads(__tstate);
4335 if (PyErr_Occurred()) SWIG_fail;
4336 }
4337 {
4338 wxRealPoint * resultptr;
4339 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4341 }
4342 return resultobj;
4343 fail:
4344 return NULL;
4345 }
4346
4347
4348 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4349 PyObject *resultobj = NULL;
4350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4351 wxRealPoint *arg2 = 0 ;
4352 wxRealPoint result;
4353 wxRealPoint temp2 ;
4354 PyObject * obj0 = 0 ;
4355 PyObject * obj1 = 0 ;
4356 char *kwnames[] = {
4357 (char *) "self",(char *) "pt", NULL
4358 };
4359
4360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4362 if (SWIG_arg_fail(1)) SWIG_fail;
4363 {
4364 arg2 = &temp2;
4365 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4366 }
4367 {
4368 PyThreadState* __tstate = wxPyBeginAllowThreads();
4369 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4370
4371 wxPyEndAllowThreads(__tstate);
4372 if (PyErr_Occurred()) SWIG_fail;
4373 }
4374 {
4375 wxRealPoint * resultptr;
4376 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4377 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4378 }
4379 return resultobj;
4380 fail:
4381 return NULL;
4382 }
4383
4384
4385 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4386 PyObject *resultobj = NULL;
4387 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4388 double arg2 ;
4389 double arg3 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 PyObject * obj2 = 0 ;
4393 char *kwnames[] = {
4394 (char *) "self",(char *) "x",(char *) "y", NULL
4395 };
4396
4397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4399 if (SWIG_arg_fail(1)) SWIG_fail;
4400 {
4401 arg2 = static_cast<double >(SWIG_As_double(obj1));
4402 if (SWIG_arg_fail(2)) SWIG_fail;
4403 }
4404 {
4405 arg3 = static_cast<double >(SWIG_As_double(obj2));
4406 if (SWIG_arg_fail(3)) SWIG_fail;
4407 }
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 wxRealPoint_Set(arg1,arg2,arg3);
4411
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 Py_INCREF(Py_None); resultobj = Py_None;
4416 return resultobj;
4417 fail:
4418 return NULL;
4419 }
4420
4421
4422 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4423 PyObject *resultobj = NULL;
4424 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4425 PyObject *result;
4426 PyObject * obj0 = 0 ;
4427 char *kwnames[] = {
4428 (char *) "self", NULL
4429 };
4430
4431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4433 if (SWIG_arg_fail(1)) SWIG_fail;
4434 {
4435 PyThreadState* __tstate = wxPyBeginAllowThreads();
4436 result = (PyObject *)wxRealPoint_Get(arg1);
4437
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 resultobj = result;
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4449 PyObject *obj;
4450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4451 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4452 Py_INCREF(obj);
4453 return Py_BuildValue((char *)"");
4454 }
4455 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj = NULL;
4457 wxPoint *arg1 = (wxPoint *) 0 ;
4458 int arg2 ;
4459 PyObject * obj0 = 0 ;
4460 PyObject * obj1 = 0 ;
4461 char *kwnames[] = {
4462 (char *) "self",(char *) "x", NULL
4463 };
4464
4465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4467 if (SWIG_arg_fail(1)) SWIG_fail;
4468 {
4469 arg2 = static_cast<int >(SWIG_As_int(obj1));
4470 if (SWIG_arg_fail(2)) SWIG_fail;
4471 }
4472 if (arg1) (arg1)->x = arg2;
4473
4474 Py_INCREF(Py_None); resultobj = Py_None;
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj = NULL;
4483 wxPoint *arg1 = (wxPoint *) 0 ;
4484 int result;
4485 PyObject * obj0 = 0 ;
4486 char *kwnames[] = {
4487 (char *) "self", NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4492 if (SWIG_arg_fail(1)) SWIG_fail;
4493 result = (int) ((arg1)->x);
4494
4495 {
4496 resultobj = SWIG_From_int(static_cast<int >(result));
4497 }
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj = NULL;
4506 wxPoint *arg1 = (wxPoint *) 0 ;
4507 int arg2 ;
4508 PyObject * obj0 = 0 ;
4509 PyObject * obj1 = 0 ;
4510 char *kwnames[] = {
4511 (char *) "self",(char *) "y", NULL
4512 };
4513
4514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4516 if (SWIG_arg_fail(1)) SWIG_fail;
4517 {
4518 arg2 = static_cast<int >(SWIG_As_int(obj1));
4519 if (SWIG_arg_fail(2)) SWIG_fail;
4520 }
4521 if (arg1) (arg1)->y = arg2;
4522
4523 Py_INCREF(Py_None); resultobj = Py_None;
4524 return resultobj;
4525 fail:
4526 return NULL;
4527 }
4528
4529
4530 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4531 PyObject *resultobj = NULL;
4532 wxPoint *arg1 = (wxPoint *) 0 ;
4533 int result;
4534 PyObject * obj0 = 0 ;
4535 char *kwnames[] = {
4536 (char *) "self", NULL
4537 };
4538
4539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4541 if (SWIG_arg_fail(1)) SWIG_fail;
4542 result = (int) ((arg1)->y);
4543
4544 {
4545 resultobj = SWIG_From_int(static_cast<int >(result));
4546 }
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
4553 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4554 PyObject *resultobj = NULL;
4555 int arg1 = (int) 0 ;
4556 int arg2 = (int) 0 ;
4557 wxPoint *result;
4558 PyObject * obj0 = 0 ;
4559 PyObject * obj1 = 0 ;
4560 char *kwnames[] = {
4561 (char *) "x",(char *) "y", NULL
4562 };
4563
4564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4565 if (obj0) {
4566 {
4567 arg1 = static_cast<int >(SWIG_As_int(obj0));
4568 if (SWIG_arg_fail(1)) SWIG_fail;
4569 }
4570 }
4571 if (obj1) {
4572 {
4573 arg2 = static_cast<int >(SWIG_As_int(obj1));
4574 if (SWIG_arg_fail(2)) SWIG_fail;
4575 }
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (wxPoint *)new wxPoint(arg1,arg2);
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4585 return resultobj;
4586 fail:
4587 return NULL;
4588 }
4589
4590
4591 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4592 PyObject *resultobj = NULL;
4593 wxPoint *arg1 = (wxPoint *) 0 ;
4594 PyObject * obj0 = 0 ;
4595 char *kwnames[] = {
4596 (char *) "self", NULL
4597 };
4598
4599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4601 if (SWIG_arg_fail(1)) SWIG_fail;
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 delete arg1;
4605
4606 wxPyEndAllowThreads(__tstate);
4607 if (PyErr_Occurred()) SWIG_fail;
4608 }
4609 Py_INCREF(Py_None); resultobj = Py_None;
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4617 PyObject *resultobj = NULL;
4618 wxPoint *arg1 = (wxPoint *) 0 ;
4619 wxPoint *arg2 = 0 ;
4620 bool result;
4621 wxPoint temp2 ;
4622 PyObject * obj0 = 0 ;
4623 PyObject * obj1 = 0 ;
4624 char *kwnames[] = {
4625 (char *) "self",(char *) "pt", NULL
4626 };
4627
4628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4630 if (SWIG_arg_fail(1)) SWIG_fail;
4631 {
4632 arg2 = &temp2;
4633 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4634 }
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4638
4639 wxPyEndAllowThreads(__tstate);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4644 }
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj = NULL;
4653 wxPoint *arg1 = (wxPoint *) 0 ;
4654 wxPoint *arg2 = 0 ;
4655 bool result;
4656 wxPoint temp2 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 char *kwnames[] = {
4660 (char *) "self",(char *) "pt", NULL
4661 };
4662
4663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4665 if (SWIG_arg_fail(1)) SWIG_fail;
4666 {
4667 arg2 = &temp2;
4668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4669 }
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4673
4674 wxPyEndAllowThreads(__tstate);
4675 if (PyErr_Occurred()) SWIG_fail;
4676 }
4677 {
4678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4679 }
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
4686 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4687 PyObject *resultobj = NULL;
4688 wxPoint *arg1 = (wxPoint *) 0 ;
4689 wxPoint *arg2 = 0 ;
4690 wxPoint result;
4691 wxPoint temp2 ;
4692 PyObject * obj0 = 0 ;
4693 PyObject * obj1 = 0 ;
4694 char *kwnames[] = {
4695 (char *) "self",(char *) "pt", NULL
4696 };
4697
4698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4700 if (SWIG_arg_fail(1)) SWIG_fail;
4701 {
4702 arg2 = &temp2;
4703 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4704 }
4705 {
4706 PyThreadState* __tstate = wxPyBeginAllowThreads();
4707 result = (arg1)->operator +((wxPoint const &)*arg2);
4708
4709 wxPyEndAllowThreads(__tstate);
4710 if (PyErr_Occurred()) SWIG_fail;
4711 }
4712 {
4713 wxPoint * resultptr;
4714 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4715 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = NULL;
4725 wxPoint *arg1 = (wxPoint *) 0 ;
4726 wxPoint *arg2 = 0 ;
4727 wxPoint result;
4728 wxPoint temp2 ;
4729 PyObject * obj0 = 0 ;
4730 PyObject * obj1 = 0 ;
4731 char *kwnames[] = {
4732 (char *) "self",(char *) "pt", NULL
4733 };
4734
4735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4737 if (SWIG_arg_fail(1)) SWIG_fail;
4738 {
4739 arg2 = &temp2;
4740 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4741 }
4742 {
4743 PyThreadState* __tstate = wxPyBeginAllowThreads();
4744 result = (arg1)->operator -((wxPoint const &)*arg2);
4745
4746 wxPyEndAllowThreads(__tstate);
4747 if (PyErr_Occurred()) SWIG_fail;
4748 }
4749 {
4750 wxPoint * resultptr;
4751 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4753 }
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = NULL;
4762 wxPoint *arg1 = (wxPoint *) 0 ;
4763 wxPoint *arg2 = 0 ;
4764 wxPoint *result;
4765 wxPoint temp2 ;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 char *kwnames[] = {
4769 (char *) "self",(char *) "pt", NULL
4770 };
4771
4772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4774 if (SWIG_arg_fail(1)) SWIG_fail;
4775 {
4776 arg2 = &temp2;
4777 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4778 }
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 {
4782 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4783 result = (wxPoint *) &_result_ref;
4784 }
4785
4786 wxPyEndAllowThreads(__tstate);
4787 if (PyErr_Occurred()) SWIG_fail;
4788 }
4789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4790 return resultobj;
4791 fail:
4792 return NULL;
4793 }
4794
4795
4796 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj = NULL;
4798 wxPoint *arg1 = (wxPoint *) 0 ;
4799 wxPoint *arg2 = 0 ;
4800 wxPoint *result;
4801 wxPoint temp2 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 char *kwnames[] = {
4805 (char *) "self",(char *) "pt", NULL
4806 };
4807
4808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4810 if (SWIG_arg_fail(1)) SWIG_fail;
4811 {
4812 arg2 = &temp2;
4813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4814 }
4815 {
4816 PyThreadState* __tstate = wxPyBeginAllowThreads();
4817 {
4818 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4819 result = (wxPoint *) &_result_ref;
4820 }
4821
4822 wxPyEndAllowThreads(__tstate);
4823 if (PyErr_Occurred()) SWIG_fail;
4824 }
4825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4826 return resultobj;
4827 fail:
4828 return NULL;
4829 }
4830
4831
4832 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4833 PyObject *resultobj = NULL;
4834 wxPoint *arg1 = (wxPoint *) 0 ;
4835 long arg2 ;
4836 long arg3 ;
4837 PyObject * obj0 = 0 ;
4838 PyObject * obj1 = 0 ;
4839 PyObject * obj2 = 0 ;
4840 char *kwnames[] = {
4841 (char *) "self",(char *) "x",(char *) "y", NULL
4842 };
4843
4844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4846 if (SWIG_arg_fail(1)) SWIG_fail;
4847 {
4848 arg2 = static_cast<long >(SWIG_As_long(obj1));
4849 if (SWIG_arg_fail(2)) SWIG_fail;
4850 }
4851 {
4852 arg3 = static_cast<long >(SWIG_As_long(obj2));
4853 if (SWIG_arg_fail(3)) SWIG_fail;
4854 }
4855 {
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 wxPoint_Set(arg1,arg2,arg3);
4858
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 Py_INCREF(Py_None); resultobj = Py_None;
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = NULL;
4871 wxPoint *arg1 = (wxPoint *) 0 ;
4872 PyObject *result;
4873 PyObject * obj0 = 0 ;
4874 char *kwnames[] = {
4875 (char *) "self", NULL
4876 };
4877
4878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4880 if (SWIG_arg_fail(1)) SWIG_fail;
4881 {
4882 PyThreadState* __tstate = wxPyBeginAllowThreads();
4883 result = (PyObject *)wxPoint_Get(arg1);
4884
4885 wxPyEndAllowThreads(__tstate);
4886 if (PyErr_Occurred()) SWIG_fail;
4887 }
4888 resultobj = result;
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4896 PyObject *obj;
4897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4898 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4899 Py_INCREF(obj);
4900 return Py_BuildValue((char *)"");
4901 }
4902 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4903 PyObject *resultobj = NULL;
4904 int arg1 = (int) 0 ;
4905 int arg2 = (int) 0 ;
4906 int arg3 = (int) 0 ;
4907 int arg4 = (int) 0 ;
4908 wxRect *result;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 PyObject * obj2 = 0 ;
4912 PyObject * obj3 = 0 ;
4913 char *kwnames[] = {
4914 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4915 };
4916
4917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4918 if (obj0) {
4919 {
4920 arg1 = static_cast<int >(SWIG_As_int(obj0));
4921 if (SWIG_arg_fail(1)) SWIG_fail;
4922 }
4923 }
4924 if (obj1) {
4925 {
4926 arg2 = static_cast<int >(SWIG_As_int(obj1));
4927 if (SWIG_arg_fail(2)) SWIG_fail;
4928 }
4929 }
4930 if (obj2) {
4931 {
4932 arg3 = static_cast<int >(SWIG_As_int(obj2));
4933 if (SWIG_arg_fail(3)) SWIG_fail;
4934 }
4935 }
4936 if (obj3) {
4937 {
4938 arg4 = static_cast<int >(SWIG_As_int(obj3));
4939 if (SWIG_arg_fail(4)) SWIG_fail;
4940 }
4941 }
4942 {
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4945
4946 wxPyEndAllowThreads(__tstate);
4947 if (PyErr_Occurred()) SWIG_fail;
4948 }
4949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4950 return resultobj;
4951 fail:
4952 return NULL;
4953 }
4954
4955
4956 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4957 PyObject *resultobj = NULL;
4958 wxPoint *arg1 = 0 ;
4959 wxPoint *arg2 = 0 ;
4960 wxRect *result;
4961 wxPoint temp1 ;
4962 wxPoint temp2 ;
4963 PyObject * obj0 = 0 ;
4964 PyObject * obj1 = 0 ;
4965 char *kwnames[] = {
4966 (char *) "topLeft",(char *) "bottomRight", NULL
4967 };
4968
4969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4970 {
4971 arg1 = &temp1;
4972 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4973 }
4974 {
4975 arg2 = &temp2;
4976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4977 }
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4981
4982 wxPyEndAllowThreads(__tstate);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj = NULL;
4994 wxPoint *arg1 = 0 ;
4995 wxSize *arg2 = 0 ;
4996 wxRect *result;
4997 wxPoint temp1 ;
4998 wxSize temp2 ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "pos",(char *) "size", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5006 {
5007 arg1 = &temp1;
5008 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5009 }
5010 {
5011 arg2 = &temp2;
5012 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5013 }
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5017
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5029 PyObject *resultobj = NULL;
5030 wxSize *arg1 = 0 ;
5031 wxRect *result;
5032 wxSize temp1 ;
5033 PyObject * obj0 = 0 ;
5034 char *kwnames[] = {
5035 (char *) "size", NULL
5036 };
5037
5038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5039 {
5040 arg1 = &temp1;
5041 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5042 }
5043 {
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5046
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5051 return resultobj;
5052 fail:
5053 return NULL;
5054 }
5055
5056
5057 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5058 PyObject *resultobj = NULL;
5059 wxRect *arg1 = (wxRect *) 0 ;
5060 PyObject * obj0 = 0 ;
5061 char *kwnames[] = {
5062 (char *) "self", NULL
5063 };
5064
5065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 delete arg1;
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 Py_INCREF(Py_None); resultobj = Py_None;
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj = NULL;
5084 wxRect *arg1 = (wxRect *) 0 ;
5085 int result;
5086 PyObject * obj0 = 0 ;
5087 char *kwnames[] = {
5088 (char *) "self", NULL
5089 };
5090
5091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5093 if (SWIG_arg_fail(1)) SWIG_fail;
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (int)((wxRect const *)arg1)->GetX();
5097
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = SWIG_From_int(static_cast<int >(result));
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = NULL;
5112 wxRect *arg1 = (wxRect *) 0 ;
5113 int arg2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "self",(char *) "x", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(1)) SWIG_fail;
5123 {
5124 arg2 = static_cast<int >(SWIG_As_int(obj1));
5125 if (SWIG_arg_fail(2)) SWIG_fail;
5126 }
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 (arg1)->SetX(arg2);
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 Py_INCREF(Py_None); resultobj = Py_None;
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj = NULL;
5143 wxRect *arg1 = (wxRect *) 0 ;
5144 int result;
5145 PyObject * obj0 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "self", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5152 if (SWIG_arg_fail(1)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (int)(arg1)->GetY();
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = SWIG_From_int(static_cast<int >(result));
5162 }
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj = NULL;
5171 wxRect *arg1 = (wxRect *) 0 ;
5172 int arg2 ;
5173 PyObject * obj0 = 0 ;
5174 PyObject * obj1 = 0 ;
5175 char *kwnames[] = {
5176 (char *) "self",(char *) "y", NULL
5177 };
5178
5179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(1)) SWIG_fail;
5182 {
5183 arg2 = static_cast<int >(SWIG_As_int(obj1));
5184 if (SWIG_arg_fail(2)) SWIG_fail;
5185 }
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 (arg1)->SetY(arg2);
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 Py_INCREF(Py_None); resultobj = Py_None;
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = NULL;
5202 wxRect *arg1 = (wxRect *) 0 ;
5203 int result;
5204 PyObject * obj0 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "self", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5211 if (SWIG_arg_fail(1)) SWIG_fail;
5212 {
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 result = (int)((wxRect const *)arg1)->GetWidth();
5215
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 {
5220 resultobj = SWIG_From_int(static_cast<int >(result));
5221 }
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj = NULL;
5230 wxRect *arg1 = (wxRect *) 0 ;
5231 int arg2 ;
5232 PyObject * obj0 = 0 ;
5233 PyObject * obj1 = 0 ;
5234 char *kwnames[] = {
5235 (char *) "self",(char *) "w", NULL
5236 };
5237
5238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5240 if (SWIG_arg_fail(1)) SWIG_fail;
5241 {
5242 arg2 = static_cast<int >(SWIG_As_int(obj1));
5243 if (SWIG_arg_fail(2)) SWIG_fail;
5244 }
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 (arg1)->SetWidth(arg2);
5248
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 Py_INCREF(Py_None); resultobj = Py_None;
5253 return resultobj;
5254 fail:
5255 return NULL;
5256 }
5257
5258
5259 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5260 PyObject *resultobj = NULL;
5261 wxRect *arg1 = (wxRect *) 0 ;
5262 int result;
5263 PyObject * obj0 = 0 ;
5264 char *kwnames[] = {
5265 (char *) "self", NULL
5266 };
5267
5268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5270 if (SWIG_arg_fail(1)) SWIG_fail;
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 result = (int)((wxRect const *)arg1)->GetHeight();
5274
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 {
5279 resultobj = SWIG_From_int(static_cast<int >(result));
5280 }
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = NULL;
5289 wxRect *arg1 = (wxRect *) 0 ;
5290 int arg2 ;
5291 PyObject * obj0 = 0 ;
5292 PyObject * obj1 = 0 ;
5293 char *kwnames[] = {
5294 (char *) "self",(char *) "h", NULL
5295 };
5296
5297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5299 if (SWIG_arg_fail(1)) SWIG_fail;
5300 {
5301 arg2 = static_cast<int >(SWIG_As_int(obj1));
5302 if (SWIG_arg_fail(2)) SWIG_fail;
5303 }
5304 {
5305 PyThreadState* __tstate = wxPyBeginAllowThreads();
5306 (arg1)->SetHeight(arg2);
5307
5308 wxPyEndAllowThreads(__tstate);
5309 if (PyErr_Occurred()) SWIG_fail;
5310 }
5311 Py_INCREF(Py_None); resultobj = Py_None;
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5319 PyObject *resultobj = NULL;
5320 wxRect *arg1 = (wxRect *) 0 ;
5321 wxPoint result;
5322 PyObject * obj0 = 0 ;
5323 char *kwnames[] = {
5324 (char *) "self", NULL
5325 };
5326
5327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5329 if (SWIG_arg_fail(1)) SWIG_fail;
5330 {
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 result = ((wxRect const *)arg1)->GetPosition();
5333
5334 wxPyEndAllowThreads(__tstate);
5335 if (PyErr_Occurred()) SWIG_fail;
5336 }
5337 {
5338 wxPoint * resultptr;
5339 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5341 }
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5349 PyObject *resultobj = NULL;
5350 wxRect *arg1 = (wxRect *) 0 ;
5351 wxPoint *arg2 = 0 ;
5352 wxPoint temp2 ;
5353 PyObject * obj0 = 0 ;
5354 PyObject * obj1 = 0 ;
5355 char *kwnames[] = {
5356 (char *) "self",(char *) "p", NULL
5357 };
5358
5359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5361 if (SWIG_arg_fail(1)) SWIG_fail;
5362 {
5363 arg2 = &temp2;
5364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5365 }
5366 {
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 (arg1)->SetPosition((wxPoint const &)*arg2);
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 Py_INCREF(Py_None); resultobj = Py_None;
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5381 PyObject *resultobj = NULL;
5382 wxRect *arg1 = (wxRect *) 0 ;
5383 wxSize result;
5384 PyObject * obj0 = 0 ;
5385 char *kwnames[] = {
5386 (char *) "self", NULL
5387 };
5388
5389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5391 if (SWIG_arg_fail(1)) SWIG_fail;
5392 {
5393 PyThreadState* __tstate = wxPyBeginAllowThreads();
5394 result = ((wxRect const *)arg1)->GetSize();
5395
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 {
5400 wxSize * resultptr;
5401 resultptr = new wxSize(static_cast<wxSize & >(result));
5402 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = NULL;
5412 wxRect *arg1 = (wxRect *) 0 ;
5413 wxSize *arg2 = 0 ;
5414 wxSize temp2 ;
5415 PyObject * obj0 = 0 ;
5416 PyObject * obj1 = 0 ;
5417 char *kwnames[] = {
5418 (char *) "self",(char *) "s", NULL
5419 };
5420
5421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5423 if (SWIG_arg_fail(1)) SWIG_fail;
5424 {
5425 arg2 = &temp2;
5426 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5427 }
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 (arg1)->SetSize((wxSize const &)*arg2);
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 Py_INCREF(Py_None); resultobj = Py_None;
5436 return resultobj;
5437 fail:
5438 return NULL;
5439 }
5440
5441
5442 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5443 PyObject *resultobj = NULL;
5444 wxRect *arg1 = (wxRect *) 0 ;
5445 bool result;
5446 PyObject * obj0 = 0 ;
5447 char *kwnames[] = {
5448 (char *) "self", NULL
5449 };
5450
5451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5453 if (SWIG_arg_fail(1)) SWIG_fail;
5454 {
5455 PyThreadState* __tstate = wxPyBeginAllowThreads();
5456 result = (bool)((wxRect const *)arg1)->IsEmpty();
5457
5458 wxPyEndAllowThreads(__tstate);
5459 if (PyErr_Occurred()) SWIG_fail;
5460 }
5461 {
5462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5463 }
5464 return resultobj;
5465 fail:
5466 return NULL;
5467 }
5468
5469
5470 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5471 PyObject *resultobj = NULL;
5472 wxRect *arg1 = (wxRect *) 0 ;
5473 wxPoint result;
5474 PyObject * obj0 = 0 ;
5475 char *kwnames[] = {
5476 (char *) "self", NULL
5477 };
5478
5479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5481 if (SWIG_arg_fail(1)) SWIG_fail;
5482 {
5483 PyThreadState* __tstate = wxPyBeginAllowThreads();
5484 result = ((wxRect const *)arg1)->GetTopLeft();
5485
5486 wxPyEndAllowThreads(__tstate);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 {
5490 wxPoint * resultptr;
5491 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5501 PyObject *resultobj = NULL;
5502 wxRect *arg1 = (wxRect *) 0 ;
5503 wxPoint *arg2 = 0 ;
5504 wxPoint temp2 ;
5505 PyObject * obj0 = 0 ;
5506 PyObject * obj1 = 0 ;
5507 char *kwnames[] = {
5508 (char *) "self",(char *) "p", NULL
5509 };
5510
5511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5513 if (SWIG_arg_fail(1)) SWIG_fail;
5514 {
5515 arg2 = &temp2;
5516 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5517 }
5518 {
5519 PyThreadState* __tstate = wxPyBeginAllowThreads();
5520 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5521
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 Py_INCREF(Py_None); resultobj = Py_None;
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5533 PyObject *resultobj = NULL;
5534 wxRect *arg1 = (wxRect *) 0 ;
5535 wxPoint result;
5536 PyObject * obj0 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5543 if (SWIG_arg_fail(1)) SWIG_fail;
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = ((wxRect const *)arg1)->GetBottomRight();
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 wxPoint * resultptr;
5553 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj = NULL;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 wxPoint *arg2 = 0 ;
5566 wxPoint temp2 ;
5567 PyObject * obj0 = 0 ;
5568 PyObject * obj1 = 0 ;
5569 char *kwnames[] = {
5570 (char *) "self",(char *) "p", NULL
5571 };
5572
5573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5575 if (SWIG_arg_fail(1)) SWIG_fail;
5576 {
5577 arg2 = &temp2;
5578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5579 }
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5583
5584 wxPyEndAllowThreads(__tstate);
5585 if (PyErr_Occurred()) SWIG_fail;
5586 }
5587 Py_INCREF(Py_None); resultobj = Py_None;
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5595 PyObject *resultobj = NULL;
5596 wxRect *arg1 = (wxRect *) 0 ;
5597 int result;
5598 PyObject * obj0 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 result = (int)((wxRect const *)arg1)->GetLeft();
5609
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 {
5614 resultobj = SWIG_From_int(static_cast<int >(result));
5615 }
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = NULL;
5624 wxRect *arg1 = (wxRect *) 0 ;
5625 int result;
5626 PyObject * obj0 = 0 ;
5627 char *kwnames[] = {
5628 (char *) "self", NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5633 if (SWIG_arg_fail(1)) SWIG_fail;
5634 {
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (int)((wxRect const *)arg1)->GetTop();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = SWIG_From_int(static_cast<int >(result));
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj = NULL;
5652 wxRect *arg1 = (wxRect *) 0 ;
5653 int result;
5654 PyObject * obj0 = 0 ;
5655 char *kwnames[] = {
5656 (char *) "self", NULL
5657 };
5658
5659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5661 if (SWIG_arg_fail(1)) SWIG_fail;
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 result = (int)((wxRect const *)arg1)->GetBottom();
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 {
5670 resultobj = SWIG_From_int(static_cast<int >(result));
5671 }
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj = NULL;
5680 wxRect *arg1 = (wxRect *) 0 ;
5681 int result;
5682 PyObject * obj0 = 0 ;
5683 char *kwnames[] = {
5684 (char *) "self", NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 {
5691 PyThreadState* __tstate = wxPyBeginAllowThreads();
5692 result = (int)((wxRect const *)arg1)->GetRight();
5693
5694 wxPyEndAllowThreads(__tstate);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 {
5698 resultobj = SWIG_From_int(static_cast<int >(result));
5699 }
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5707 PyObject *resultobj = NULL;
5708 wxRect *arg1 = (wxRect *) 0 ;
5709 int arg2 ;
5710 PyObject * obj0 = 0 ;
5711 PyObject * obj1 = 0 ;
5712 char *kwnames[] = {
5713 (char *) "self",(char *) "left", NULL
5714 };
5715
5716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5718 if (SWIG_arg_fail(1)) SWIG_fail;
5719 {
5720 arg2 = static_cast<int >(SWIG_As_int(obj1));
5721 if (SWIG_arg_fail(2)) SWIG_fail;
5722 }
5723 {
5724 PyThreadState* __tstate = wxPyBeginAllowThreads();
5725 (arg1)->SetLeft(arg2);
5726
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 Py_INCREF(Py_None); resultobj = Py_None;
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5738 PyObject *resultobj = NULL;
5739 wxRect *arg1 = (wxRect *) 0 ;
5740 int arg2 ;
5741 PyObject * obj0 = 0 ;
5742 PyObject * obj1 = 0 ;
5743 char *kwnames[] = {
5744 (char *) "self",(char *) "right", NULL
5745 };
5746
5747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5749 if (SWIG_arg_fail(1)) SWIG_fail;
5750 {
5751 arg2 = static_cast<int >(SWIG_As_int(obj1));
5752 if (SWIG_arg_fail(2)) SWIG_fail;
5753 }
5754 {
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 (arg1)->SetRight(arg2);
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 Py_INCREF(Py_None); resultobj = Py_None;
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj = NULL;
5770 wxRect *arg1 = (wxRect *) 0 ;
5771 int arg2 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char *kwnames[] = {
5775 (char *) "self",(char *) "top", NULL
5776 };
5777
5778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5780 if (SWIG_arg_fail(1)) SWIG_fail;
5781 {
5782 arg2 = static_cast<int >(SWIG_As_int(obj1));
5783 if (SWIG_arg_fail(2)) SWIG_fail;
5784 }
5785 {
5786 PyThreadState* __tstate = wxPyBeginAllowThreads();
5787 (arg1)->SetTop(arg2);
5788
5789 wxPyEndAllowThreads(__tstate);
5790 if (PyErr_Occurred()) SWIG_fail;
5791 }
5792 Py_INCREF(Py_None); resultobj = Py_None;
5793 return resultobj;
5794 fail:
5795 return NULL;
5796 }
5797
5798
5799 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5800 PyObject *resultobj = NULL;
5801 wxRect *arg1 = (wxRect *) 0 ;
5802 int arg2 ;
5803 PyObject * obj0 = 0 ;
5804 PyObject * obj1 = 0 ;
5805 char *kwnames[] = {
5806 (char *) "self",(char *) "bottom", NULL
5807 };
5808
5809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5811 if (SWIG_arg_fail(1)) SWIG_fail;
5812 {
5813 arg2 = static_cast<int >(SWIG_As_int(obj1));
5814 if (SWIG_arg_fail(2)) SWIG_fail;
5815 }
5816 {
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 (arg1)->SetBottom(arg2);
5819
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 Py_INCREF(Py_None); resultobj = Py_None;
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = NULL;
5832 wxRect *arg1 = (wxRect *) 0 ;
5833 int arg2 ;
5834 int arg3 ;
5835 wxRect *result;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 PyObject * obj2 = 0 ;
5839 char *kwnames[] = {
5840 (char *) "self",(char *) "dx",(char *) "dy", NULL
5841 };
5842
5843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5845 if (SWIG_arg_fail(1)) SWIG_fail;
5846 {
5847 arg2 = static_cast<int >(SWIG_As_int(obj1));
5848 if (SWIG_arg_fail(2)) SWIG_fail;
5849 }
5850 {
5851 arg3 = static_cast<int >(SWIG_As_int(obj2));
5852 if (SWIG_arg_fail(3)) SWIG_fail;
5853 }
5854 {
5855 PyThreadState* __tstate = wxPyBeginAllowThreads();
5856 {
5857 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5858 result = (wxRect *) &_result_ref;
5859 }
5860
5861 wxPyEndAllowThreads(__tstate);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj = NULL;
5873 wxRect *arg1 = (wxRect *) 0 ;
5874 int arg2 ;
5875 int arg3 ;
5876 wxRect *result;
5877 PyObject * obj0 = 0 ;
5878 PyObject * obj1 = 0 ;
5879 PyObject * obj2 = 0 ;
5880 char *kwnames[] = {
5881 (char *) "self",(char *) "dx",(char *) "dy", NULL
5882 };
5883
5884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5886 if (SWIG_arg_fail(1)) SWIG_fail;
5887 {
5888 arg2 = static_cast<int >(SWIG_As_int(obj1));
5889 if (SWIG_arg_fail(2)) SWIG_fail;
5890 }
5891 {
5892 arg3 = static_cast<int >(SWIG_As_int(obj2));
5893 if (SWIG_arg_fail(3)) SWIG_fail;
5894 }
5895 {
5896 PyThreadState* __tstate = wxPyBeginAllowThreads();
5897 {
5898 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5899 result = (wxRect *) &_result_ref;
5900 }
5901
5902 wxPyEndAllowThreads(__tstate);
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5906 return resultobj;
5907 fail:
5908 return NULL;
5909 }
5910
5911
5912 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5913 PyObject *resultobj = NULL;
5914 wxRect *arg1 = (wxRect *) 0 ;
5915 int arg2 ;
5916 int arg3 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 PyObject * obj2 = 0 ;
5920 char *kwnames[] = {
5921 (char *) "self",(char *) "dx",(char *) "dy", NULL
5922 };
5923
5924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5926 if (SWIG_arg_fail(1)) SWIG_fail;
5927 {
5928 arg2 = static_cast<int >(SWIG_As_int(obj1));
5929 if (SWIG_arg_fail(2)) SWIG_fail;
5930 }
5931 {
5932 arg3 = static_cast<int >(SWIG_As_int(obj2));
5933 if (SWIG_arg_fail(3)) SWIG_fail;
5934 }
5935 {
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 (arg1)->Offset(arg2,arg3);
5938
5939 wxPyEndAllowThreads(__tstate);
5940 if (PyErr_Occurred()) SWIG_fail;
5941 }
5942 Py_INCREF(Py_None); resultobj = Py_None;
5943 return resultobj;
5944 fail:
5945 return NULL;
5946 }
5947
5948
5949 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj = NULL;
5951 wxRect *arg1 = (wxRect *) 0 ;
5952 wxPoint *arg2 = 0 ;
5953 wxPoint temp2 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "self",(char *) "pt", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5962 if (SWIG_arg_fail(1)) SWIG_fail;
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 (arg1)->Offset((wxPoint const &)*arg2);
5970
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 Py_INCREF(Py_None); resultobj = Py_None;
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = NULL;
5983 wxRect *arg1 = (wxRect *) 0 ;
5984 wxRect *arg2 = 0 ;
5985 wxRect result;
5986 wxRect temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char *kwnames[] = {
5990 (char *) "self",(char *) "rect", NULL
5991 };
5992
5993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5995 if (SWIG_arg_fail(1)) SWIG_fail;
5996 {
5997 arg2 = &temp2;
5998 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5999 }
6000 {
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 result = (arg1)->Intersect((wxRect const &)*arg2);
6003
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 {
6008 wxRect * resultptr;
6009 resultptr = new wxRect(static_cast<wxRect & >(result));
6010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6011 }
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj = NULL;
6020 wxRect *arg1 = (wxRect *) 0 ;
6021 wxRect *arg2 = 0 ;
6022 wxRect result;
6023 wxRect temp2 ;
6024 PyObject * obj0 = 0 ;
6025 PyObject * obj1 = 0 ;
6026 char *kwnames[] = {
6027 (char *) "self",(char *) "rect", NULL
6028 };
6029
6030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6032 if (SWIG_arg_fail(1)) SWIG_fail;
6033 {
6034 arg2 = &temp2;
6035 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6036 }
6037 {
6038 PyThreadState* __tstate = wxPyBeginAllowThreads();
6039 result = (arg1)->Union((wxRect const &)*arg2);
6040
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 {
6045 wxRect * resultptr;
6046 resultptr = new wxRect(static_cast<wxRect & >(result));
6047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6048 }
6049 return resultobj;
6050 fail:
6051 return NULL;
6052 }
6053
6054
6055 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6056 PyObject *resultobj = NULL;
6057 wxRect *arg1 = (wxRect *) 0 ;
6058 wxRect *arg2 = 0 ;
6059 wxRect result;
6060 wxRect temp2 ;
6061 PyObject * obj0 = 0 ;
6062 PyObject * obj1 = 0 ;
6063 char *kwnames[] = {
6064 (char *) "self",(char *) "rect", NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6069 if (SWIG_arg_fail(1)) SWIG_fail;
6070 {
6071 arg2 = &temp2;
6072 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6073 }
6074 {
6075 PyThreadState* __tstate = wxPyBeginAllowThreads();
6076 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6077
6078 wxPyEndAllowThreads(__tstate);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 {
6082 wxRect * resultptr;
6083 resultptr = new wxRect(static_cast<wxRect & >(result));
6084 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6085 }
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj = NULL;
6094 wxRect *arg1 = (wxRect *) 0 ;
6095 wxRect *arg2 = 0 ;
6096 wxRect *result;
6097 wxRect temp2 ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 char *kwnames[] = {
6101 (char *) "self",(char *) "rect", NULL
6102 };
6103
6104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6106 if (SWIG_arg_fail(1)) SWIG_fail;
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 {
6114 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6115 result = (wxRect *) &_result_ref;
6116 }
6117
6118 wxPyEndAllowThreads(__tstate);
6119 if (PyErr_Occurred()) SWIG_fail;
6120 }
6121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6129 PyObject *resultobj = NULL;
6130 wxRect *arg1 = (wxRect *) 0 ;
6131 wxRect *arg2 = 0 ;
6132 bool result;
6133 wxRect temp2 ;
6134 PyObject * obj0 = 0 ;
6135 PyObject * obj1 = 0 ;
6136 char *kwnames[] = {
6137 (char *) "self",(char *) "rect", NULL
6138 };
6139
6140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6142 if (SWIG_arg_fail(1)) SWIG_fail;
6143 {
6144 arg2 = &temp2;
6145 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6146 }
6147 {
6148 PyThreadState* __tstate = wxPyBeginAllowThreads();
6149 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6150
6151 wxPyEndAllowThreads(__tstate);
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 {
6155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6156 }
6157 return resultobj;
6158 fail:
6159 return NULL;
6160 }
6161
6162
6163 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6164 PyObject *resultobj = NULL;
6165 wxRect *arg1 = (wxRect *) 0 ;
6166 wxRect *arg2 = 0 ;
6167 bool result;
6168 wxRect temp2 ;
6169 PyObject * obj0 = 0 ;
6170 PyObject * obj1 = 0 ;
6171 char *kwnames[] = {
6172 (char *) "self",(char *) "rect", NULL
6173 };
6174
6175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6177 if (SWIG_arg_fail(1)) SWIG_fail;
6178 {
6179 arg2 = &temp2;
6180 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6181 }
6182 {
6183 PyThreadState* __tstate = wxPyBeginAllowThreads();
6184 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6185
6186 wxPyEndAllowThreads(__tstate);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 {
6190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6191 }
6192 return resultobj;
6193 fail:
6194 return NULL;
6195 }
6196
6197
6198 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6199 PyObject *resultobj = NULL;
6200 wxRect *arg1 = (wxRect *) 0 ;
6201 int arg2 ;
6202 int arg3 ;
6203 bool result;
6204 PyObject * obj0 = 0 ;
6205 PyObject * obj1 = 0 ;
6206 PyObject * obj2 = 0 ;
6207 char *kwnames[] = {
6208 (char *) "self",(char *) "x",(char *) "y", NULL
6209 };
6210
6211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6213 if (SWIG_arg_fail(1)) SWIG_fail;
6214 {
6215 arg2 = static_cast<int >(SWIG_As_int(obj1));
6216 if (SWIG_arg_fail(2)) SWIG_fail;
6217 }
6218 {
6219 arg3 = static_cast<int >(SWIG_As_int(obj2));
6220 if (SWIG_arg_fail(3)) SWIG_fail;
6221 }
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6225
6226 wxPyEndAllowThreads(__tstate);
6227 if (PyErr_Occurred()) SWIG_fail;
6228 }
6229 {
6230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6231 }
6232 return resultobj;
6233 fail:
6234 return NULL;
6235 }
6236
6237
6238 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6239 PyObject *resultobj = NULL;
6240 wxRect *arg1 = (wxRect *) 0 ;
6241 wxPoint *arg2 = 0 ;
6242 bool result;
6243 wxPoint temp2 ;
6244 PyObject * obj0 = 0 ;
6245 PyObject * obj1 = 0 ;
6246 char *kwnames[] = {
6247 (char *) "self",(char *) "pt", NULL
6248 };
6249
6250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6252 if (SWIG_arg_fail(1)) SWIG_fail;
6253 {
6254 arg2 = &temp2;
6255 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6256 }
6257 {
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6260
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 {
6265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6266 }
6267 return resultobj;
6268 fail:
6269 return NULL;
6270 }
6271
6272
6273 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = NULL;
6275 wxRect *arg1 = (wxRect *) 0 ;
6276 wxRect *arg2 = 0 ;
6277 bool result;
6278 wxRect temp2 ;
6279 PyObject * obj0 = 0 ;
6280 PyObject * obj1 = 0 ;
6281 char *kwnames[] = {
6282 (char *) "self",(char *) "rect", NULL
6283 };
6284
6285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6287 if (SWIG_arg_fail(1)) SWIG_fail;
6288 {
6289 arg2 = &temp2;
6290 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6291 }
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6295
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 {
6300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6301 }
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj = NULL;
6310 wxRect *arg1 = (wxRect *) 0 ;
6311 int arg2 ;
6312 PyObject * obj0 = 0 ;
6313 PyObject * obj1 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self",(char *) "x", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 {
6322 arg2 = static_cast<int >(SWIG_As_int(obj1));
6323 if (SWIG_arg_fail(2)) SWIG_fail;
6324 }
6325 if (arg1) (arg1)->x = arg2;
6326
6327 Py_INCREF(Py_None); resultobj = Py_None;
6328 return resultobj;
6329 fail:
6330 return NULL;
6331 }
6332
6333
6334 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6335 PyObject *resultobj = NULL;
6336 wxRect *arg1 = (wxRect *) 0 ;
6337 int result;
6338 PyObject * obj0 = 0 ;
6339 char *kwnames[] = {
6340 (char *) "self", NULL
6341 };
6342
6343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 result = (int) ((arg1)->x);
6347
6348 {
6349 resultobj = SWIG_From_int(static_cast<int >(result));
6350 }
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj = NULL;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 int arg2 ;
6361 PyObject * obj0 = 0 ;
6362 PyObject * obj1 = 0 ;
6363 char *kwnames[] = {
6364 (char *) "self",(char *) "y", NULL
6365 };
6366
6367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6369 if (SWIG_arg_fail(1)) SWIG_fail;
6370 {
6371 arg2 = static_cast<int >(SWIG_As_int(obj1));
6372 if (SWIG_arg_fail(2)) SWIG_fail;
6373 }
6374 if (arg1) (arg1)->y = arg2;
6375
6376 Py_INCREF(Py_None); resultobj = Py_None;
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6384 PyObject *resultobj = NULL;
6385 wxRect *arg1 = (wxRect *) 0 ;
6386 int result;
6387 PyObject * obj0 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self", NULL
6390 };
6391
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 result = (int) ((arg1)->y);
6396
6397 {
6398 resultobj = SWIG_From_int(static_cast<int >(result));
6399 }
6400 return resultobj;
6401 fail:
6402 return NULL;
6403 }
6404
6405
6406 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6407 PyObject *resultobj = NULL;
6408 wxRect *arg1 = (wxRect *) 0 ;
6409 int arg2 ;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char *kwnames[] = {
6413 (char *) "self",(char *) "width", NULL
6414 };
6415
6416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6418 if (SWIG_arg_fail(1)) SWIG_fail;
6419 {
6420 arg2 = static_cast<int >(SWIG_As_int(obj1));
6421 if (SWIG_arg_fail(2)) SWIG_fail;
6422 }
6423 if (arg1) (arg1)->width = arg2;
6424
6425 Py_INCREF(Py_None); resultobj = Py_None;
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj = NULL;
6434 wxRect *arg1 = (wxRect *) 0 ;
6435 int result;
6436 PyObject * obj0 = 0 ;
6437 char *kwnames[] = {
6438 (char *) "self", NULL
6439 };
6440
6441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6443 if (SWIG_arg_fail(1)) SWIG_fail;
6444 result = (int) ((arg1)->width);
6445
6446 {
6447 resultobj = SWIG_From_int(static_cast<int >(result));
6448 }
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj = NULL;
6457 wxRect *arg1 = (wxRect *) 0 ;
6458 int arg2 ;
6459 PyObject * obj0 = 0 ;
6460 PyObject * obj1 = 0 ;
6461 char *kwnames[] = {
6462 (char *) "self",(char *) "height", NULL
6463 };
6464
6465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6467 if (SWIG_arg_fail(1)) SWIG_fail;
6468 {
6469 arg2 = static_cast<int >(SWIG_As_int(obj1));
6470 if (SWIG_arg_fail(2)) SWIG_fail;
6471 }
6472 if (arg1) (arg1)->height = arg2;
6473
6474 Py_INCREF(Py_None); resultobj = Py_None;
6475 return resultobj;
6476 fail:
6477 return NULL;
6478 }
6479
6480
6481 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6482 PyObject *resultobj = NULL;
6483 wxRect *arg1 = (wxRect *) 0 ;
6484 int result;
6485 PyObject * obj0 = 0 ;
6486 char *kwnames[] = {
6487 (char *) "self", NULL
6488 };
6489
6490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6492 if (SWIG_arg_fail(1)) SWIG_fail;
6493 result = (int) ((arg1)->height);
6494
6495 {
6496 resultobj = SWIG_From_int(static_cast<int >(result));
6497 }
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = NULL;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 = (int) 0 ;
6508 int arg3 = (int) 0 ;
6509 int arg4 = (int) 0 ;
6510 int arg5 = (int) 0 ;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 PyObject * obj2 = 0 ;
6514 PyObject * obj3 = 0 ;
6515 PyObject * obj4 = 0 ;
6516 char *kwnames[] = {
6517 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6518 };
6519
6520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6522 if (SWIG_arg_fail(1)) SWIG_fail;
6523 if (obj1) {
6524 {
6525 arg2 = static_cast<int >(SWIG_As_int(obj1));
6526 if (SWIG_arg_fail(2)) SWIG_fail;
6527 }
6528 }
6529 if (obj2) {
6530 {
6531 arg3 = static_cast<int >(SWIG_As_int(obj2));
6532 if (SWIG_arg_fail(3)) SWIG_fail;
6533 }
6534 }
6535 if (obj3) {
6536 {
6537 arg4 = static_cast<int >(SWIG_As_int(obj3));
6538 if (SWIG_arg_fail(4)) SWIG_fail;
6539 }
6540 }
6541 if (obj4) {
6542 {
6543 arg5 = static_cast<int >(SWIG_As_int(obj4));
6544 if (SWIG_arg_fail(5)) SWIG_fail;
6545 }
6546 }
6547 {
6548 PyThreadState* __tstate = wxPyBeginAllowThreads();
6549 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6550
6551 wxPyEndAllowThreads(__tstate);
6552 if (PyErr_Occurred()) SWIG_fail;
6553 }
6554 Py_INCREF(Py_None); resultobj = Py_None;
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj = NULL;
6563 wxRect *arg1 = (wxRect *) 0 ;
6564 PyObject *result;
6565 PyObject * obj0 = 0 ;
6566 char *kwnames[] = {
6567 (char *) "self", NULL
6568 };
6569
6570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6572 if (SWIG_arg_fail(1)) SWIG_fail;
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (PyObject *)wxRect_Get(arg1);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = result;
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6588 PyObject *obj;
6589 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6590 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6591 Py_INCREF(obj);
6592 return Py_BuildValue((char *)"");
6593 }
6594 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6595 PyObject *resultobj = NULL;
6596 wxRect *arg1 = (wxRect *) 0 ;
6597 wxRect *arg2 = (wxRect *) 0 ;
6598 PyObject *result;
6599 PyObject * obj0 = 0 ;
6600 PyObject * obj1 = 0 ;
6601 char *kwnames[] = {
6602 (char *) "r1",(char *) "r2", NULL
6603 };
6604
6605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6607 if (SWIG_arg_fail(1)) SWIG_fail;
6608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6609 if (SWIG_arg_fail(2)) SWIG_fail;
6610 {
6611 if (!wxPyCheckForApp()) SWIG_fail;
6612 PyThreadState* __tstate = wxPyBeginAllowThreads();
6613 result = (PyObject *)wxIntersectRect(arg1,arg2);
6614
6615 wxPyEndAllowThreads(__tstate);
6616 if (PyErr_Occurred()) SWIG_fail;
6617 }
6618 resultobj = result;
6619 return resultobj;
6620 fail:
6621 return NULL;
6622 }
6623
6624
6625 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6626 PyObject *resultobj = NULL;
6627 double arg1 = (double) 0.0 ;
6628 double arg2 = (double) 0.0 ;
6629 wxPoint2D *result;
6630 PyObject * obj0 = 0 ;
6631 PyObject * obj1 = 0 ;
6632 char *kwnames[] = {
6633 (char *) "x",(char *) "y", NULL
6634 };
6635
6636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6637 if (obj0) {
6638 {
6639 arg1 = static_cast<double >(SWIG_As_double(obj0));
6640 if (SWIG_arg_fail(1)) SWIG_fail;
6641 }
6642 }
6643 if (obj1) {
6644 {
6645 arg2 = static_cast<double >(SWIG_As_double(obj1));
6646 if (SWIG_arg_fail(2)) SWIG_fail;
6647 }
6648 }
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj = NULL;
6665 wxPoint2D *arg1 = 0 ;
6666 wxPoint2D *result;
6667 wxPoint2D temp1 ;
6668 PyObject * obj0 = 0 ;
6669 char *kwnames[] = {
6670 (char *) "pt", NULL
6671 };
6672
6673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6674 {
6675 arg1 = &temp1;
6676 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6677 }
6678 {
6679 PyThreadState* __tstate = wxPyBeginAllowThreads();
6680 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6681
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj = NULL;
6694 wxPoint *arg1 = 0 ;
6695 wxPoint2D *result;
6696 wxPoint temp1 ;
6697 PyObject * obj0 = 0 ;
6698 char *kwnames[] = {
6699 (char *) "pt", NULL
6700 };
6701
6702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6703 {
6704 arg1 = &temp1;
6705 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6706 }
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = NULL;
6723 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6724 int *arg2 = (int *) 0 ;
6725 int *arg3 = (int *) 0 ;
6726 int temp2 ;
6727 int res2 = 0 ;
6728 int temp3 ;
6729 int res3 = 0 ;
6730 PyObject * obj0 = 0 ;
6731 char *kwnames[] = {
6732 (char *) "self", NULL
6733 };
6734
6735 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6736 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6739 if (SWIG_arg_fail(1)) SWIG_fail;
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6743
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 Py_INCREF(Py_None); resultobj = Py_None;
6748 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6749 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6750 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6751 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6759 PyObject *resultobj = NULL;
6760 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6761 int *arg2 = (int *) 0 ;
6762 int *arg3 = (int *) 0 ;
6763 int temp2 ;
6764 int res2 = 0 ;
6765 int temp3 ;
6766 int res3 = 0 ;
6767 PyObject * obj0 = 0 ;
6768 char *kwnames[] = {
6769 (char *) "self", NULL
6770 };
6771
6772 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6773 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6776 if (SWIG_arg_fail(1)) SWIG_fail;
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 Py_INCREF(Py_None); resultobj = Py_None;
6785 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6786 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6787 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6788 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj = NULL;
6797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6798 double result;
6799 PyObject * obj0 = 0 ;
6800 char *kwnames[] = {
6801 (char *) "self", NULL
6802 };
6803
6804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6806 if (SWIG_arg_fail(1)) SWIG_fail;
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6810
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 {
6815 resultobj = SWIG_From_double(static_cast<double >(result));
6816 }
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj = NULL;
6825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6826 double result;
6827 PyObject * obj0 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 {
6843 resultobj = SWIG_From_double(static_cast<double >(result));
6844 }
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6852 PyObject *resultobj = NULL;
6853 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6854 double arg2 ;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char *kwnames[] = {
6858 (char *) "self",(char *) "length", NULL
6859 };
6860
6861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6863 if (SWIG_arg_fail(1)) SWIG_fail;
6864 {
6865 arg2 = static_cast<double >(SWIG_As_double(obj1));
6866 if (SWIG_arg_fail(2)) SWIG_fail;
6867 }
6868 {
6869 PyThreadState* __tstate = wxPyBeginAllowThreads();
6870 (arg1)->SetVectorLength(arg2);
6871
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 Py_INCREF(Py_None); resultobj = Py_None;
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj = NULL;
6884 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6885 double arg2 ;
6886 PyObject * obj0 = 0 ;
6887 PyObject * obj1 = 0 ;
6888 char *kwnames[] = {
6889 (char *) "self",(char *) "degrees", NULL
6890 };
6891
6892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6894 if (SWIG_arg_fail(1)) SWIG_fail;
6895 {
6896 arg2 = static_cast<double >(SWIG_As_double(obj1));
6897 if (SWIG_arg_fail(2)) SWIG_fail;
6898 }
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 (arg1)->SetVectorAngle(arg2);
6902
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 Py_INCREF(Py_None); resultobj = Py_None;
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6914 PyObject *resultobj = NULL;
6915 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6916 wxPoint2D *arg2 = 0 ;
6917 double result;
6918 wxPoint2D temp2 ;
6919 PyObject * obj0 = 0 ;
6920 PyObject * obj1 = 0 ;
6921 char *kwnames[] = {
6922 (char *) "self",(char *) "pt", NULL
6923 };
6924
6925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6927 if (SWIG_arg_fail(1)) SWIG_fail;
6928 {
6929 arg2 = &temp2;
6930 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6931 }
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 {
6940 resultobj = SWIG_From_double(static_cast<double >(result));
6941 }
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj = NULL;
6950 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6951 wxPoint2D *arg2 = 0 ;
6952 double result;
6953 wxPoint2D temp2 ;
6954 PyObject * obj0 = 0 ;
6955 PyObject * obj1 = 0 ;
6956 char *kwnames[] = {
6957 (char *) "self",(char *) "pt", NULL
6958 };
6959
6960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6962 if (SWIG_arg_fail(1)) SWIG_fail;
6963 {
6964 arg2 = &temp2;
6965 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6966 }
6967 {
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6970
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 {
6975 resultobj = SWIG_From_double(static_cast<double >(result));
6976 }
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6984 PyObject *resultobj = NULL;
6985 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6986 wxPoint2D *arg2 = 0 ;
6987 double result;
6988 wxPoint2D temp2 ;
6989 PyObject * obj0 = 0 ;
6990 PyObject * obj1 = 0 ;
6991 char *kwnames[] = {
6992 (char *) "self",(char *) "vec", NULL
6993 };
6994
6995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6997 if (SWIG_arg_fail(1)) SWIG_fail;
6998 {
6999 arg2 = &temp2;
7000 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7001 }
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7005
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 {
7010 resultobj = SWIG_From_double(static_cast<double >(result));
7011 }
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj = NULL;
7020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7021 wxPoint2D *arg2 = 0 ;
7022 double result;
7023 wxPoint2D temp2 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char *kwnames[] = {
7027 (char *) "self",(char *) "vec", NULL
7028 };
7029
7030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7032 if (SWIG_arg_fail(1)) SWIG_fail;
7033 {
7034 arg2 = &temp2;
7035 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7036 }
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 {
7045 resultobj = SWIG_From_double(static_cast<double >(result));
7046 }
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj = NULL;
7055 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7056 wxPoint2D result;
7057 PyObject * obj0 = 0 ;
7058 char *kwnames[] = {
7059 (char *) "self", NULL
7060 };
7061
7062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7064 if (SWIG_arg_fail(1)) SWIG_fail;
7065 {
7066 PyThreadState* __tstate = wxPyBeginAllowThreads();
7067 result = (arg1)->operator -();
7068
7069 wxPyEndAllowThreads(__tstate);
7070 if (PyErr_Occurred()) SWIG_fail;
7071 }
7072 {
7073 wxPoint2D * resultptr;
7074 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7076 }
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj = NULL;
7085 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7086 wxPoint2D *arg2 = 0 ;
7087 wxPoint2D *result;
7088 wxPoint2D temp2 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 char *kwnames[] = {
7092 (char *) "self",(char *) "pt", NULL
7093 };
7094
7095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7097 if (SWIG_arg_fail(1)) SWIG_fail;
7098 {
7099 arg2 = &temp2;
7100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7101 }
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 {
7105 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7106 result = (wxPoint2D *) &_result_ref;
7107 }
7108
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7120 PyObject *resultobj = NULL;
7121 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7122 wxPoint2D *arg2 = 0 ;
7123 wxPoint2D *result;
7124 wxPoint2D temp2 ;
7125 PyObject * obj0 = 0 ;
7126 PyObject * obj1 = 0 ;
7127 char *kwnames[] = {
7128 (char *) "self",(char *) "pt", NULL
7129 };
7130
7131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7133 if (SWIG_arg_fail(1)) SWIG_fail;
7134 {
7135 arg2 = &temp2;
7136 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7137 }
7138 {
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 {
7141 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7142 result = (wxPoint2D *) &_result_ref;
7143 }
7144
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7149 return resultobj;
7150 fail:
7151 return NULL;
7152 }
7153
7154
7155 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7156 PyObject *resultobj = NULL;
7157 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7158 wxPoint2D *arg2 = 0 ;
7159 wxPoint2D *result;
7160 wxPoint2D temp2 ;
7161 PyObject * obj0 = 0 ;
7162 PyObject * obj1 = 0 ;
7163 char *kwnames[] = {
7164 (char *) "self",(char *) "pt", NULL
7165 };
7166
7167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7169 if (SWIG_arg_fail(1)) SWIG_fail;
7170 {
7171 arg2 = &temp2;
7172 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7173 }
7174 {
7175 PyThreadState* __tstate = wxPyBeginAllowThreads();
7176 {
7177 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7178 result = (wxPoint2D *) &_result_ref;
7179 }
7180
7181 wxPyEndAllowThreads(__tstate);
7182 if (PyErr_Occurred()) SWIG_fail;
7183 }
7184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7185 return resultobj;
7186 fail:
7187 return NULL;
7188 }
7189
7190
7191 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7192 PyObject *resultobj = NULL;
7193 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7194 wxPoint2D *arg2 = 0 ;
7195 wxPoint2D *result;
7196 wxPoint2D temp2 ;
7197 PyObject * obj0 = 0 ;
7198 PyObject * obj1 = 0 ;
7199 char *kwnames[] = {
7200 (char *) "self",(char *) "pt", NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 {
7207 arg2 = &temp2;
7208 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7209 }
7210 {
7211 PyThreadState* __tstate = wxPyBeginAllowThreads();
7212 {
7213 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7214 result = (wxPoint2D *) &_result_ref;
7215 }
7216
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = NULL;
7229 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7230 wxPoint2D *arg2 = 0 ;
7231 bool result;
7232 wxPoint2D temp2 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 char *kwnames[] = {
7236 (char *) "self",(char *) "pt", NULL
7237 };
7238
7239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7241 if (SWIG_arg_fail(1)) SWIG_fail;
7242 {
7243 arg2 = &temp2;
7244 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7245 }
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7249
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 {
7254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7255 }
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = NULL;
7264 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7265 wxPoint2D *arg2 = 0 ;
7266 bool result;
7267 wxPoint2D temp2 ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 char *kwnames[] = {
7271 (char *) "self",(char *) "pt", NULL
7272 };
7273
7274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7276 if (SWIG_arg_fail(1)) SWIG_fail;
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 {
7289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7290 }
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj = NULL;
7299 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7300 double arg2 ;
7301 PyObject * obj0 = 0 ;
7302 PyObject * obj1 = 0 ;
7303 char *kwnames[] = {
7304 (char *) "self",(char *) "m_x", NULL
7305 };
7306
7307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 {
7311 arg2 = static_cast<double >(SWIG_As_double(obj1));
7312 if (SWIG_arg_fail(2)) SWIG_fail;
7313 }
7314 if (arg1) (arg1)->m_x = arg2;
7315
7316 Py_INCREF(Py_None); resultobj = Py_None;
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7324 PyObject *resultobj = NULL;
7325 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7326 double result;
7327 PyObject * obj0 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 result = (double) ((arg1)->m_x);
7336
7337 {
7338 resultobj = SWIG_From_double(static_cast<double >(result));
7339 }
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj = NULL;
7348 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7349 double arg2 ;
7350 PyObject * obj0 = 0 ;
7351 PyObject * obj1 = 0 ;
7352 char *kwnames[] = {
7353 (char *) "self",(char *) "m_y", NULL
7354 };
7355
7356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7358 if (SWIG_arg_fail(1)) SWIG_fail;
7359 {
7360 arg2 = static_cast<double >(SWIG_As_double(obj1));
7361 if (SWIG_arg_fail(2)) SWIG_fail;
7362 }
7363 if (arg1) (arg1)->m_y = arg2;
7364
7365 Py_INCREF(Py_None); resultobj = Py_None;
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj = NULL;
7374 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7375 double result;
7376 PyObject * obj0 = 0 ;
7377 char *kwnames[] = {
7378 (char *) "self", NULL
7379 };
7380
7381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7383 if (SWIG_arg_fail(1)) SWIG_fail;
7384 result = (double) ((arg1)->m_y);
7385
7386 {
7387 resultobj = SWIG_From_double(static_cast<double >(result));
7388 }
7389 return resultobj;
7390 fail:
7391 return NULL;
7392 }
7393
7394
7395 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7396 PyObject *resultobj = NULL;
7397 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7398 double arg2 = (double) 0 ;
7399 double arg3 = (double) 0 ;
7400 PyObject * obj0 = 0 ;
7401 PyObject * obj1 = 0 ;
7402 PyObject * obj2 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self",(char *) "x",(char *) "y", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 if (obj1) {
7411 {
7412 arg2 = static_cast<double >(SWIG_As_double(obj1));
7413 if (SWIG_arg_fail(2)) SWIG_fail;
7414 }
7415 }
7416 if (obj2) {
7417 {
7418 arg3 = static_cast<double >(SWIG_As_double(obj2));
7419 if (SWIG_arg_fail(3)) SWIG_fail;
7420 }
7421 }
7422 {
7423 PyThreadState* __tstate = wxPyBeginAllowThreads();
7424 wxPoint2D_Set(arg1,arg2,arg3);
7425
7426 wxPyEndAllowThreads(__tstate);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 Py_INCREF(Py_None); resultobj = Py_None;
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7437 PyObject *resultobj = NULL;
7438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7439 PyObject *result;
7440 PyObject * obj0 = 0 ;
7441 char *kwnames[] = {
7442 (char *) "self", NULL
7443 };
7444
7445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7447 if (SWIG_arg_fail(1)) SWIG_fail;
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (PyObject *)wxPoint2D_Get(arg1);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 resultobj = result;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7463 PyObject *obj;
7464 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7465 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7466 Py_INCREF(obj);
7467 return Py_BuildValue((char *)"");
7468 }
7469 static int _wrap_DefaultPosition_set(PyObject *) {
7470 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7471 return 1;
7472 }
7473
7474
7475 static PyObject *_wrap_DefaultPosition_get(void) {
7476 PyObject *pyobj = NULL;
7477
7478 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7479 return pyobj;
7480 }
7481
7482
7483 static int _wrap_DefaultSize_set(PyObject *) {
7484 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7485 return 1;
7486 }
7487
7488
7489 static PyObject *_wrap_DefaultSize_get(void) {
7490 PyObject *pyobj = NULL;
7491
7492 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7493 return pyobj;
7494 }
7495
7496
7497 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj = NULL;
7499 PyObject *arg1 = (PyObject *) 0 ;
7500 wxPyInputStream *result;
7501 PyObject * obj0 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "p", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7507 arg1 = obj0;
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7511
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj = NULL;
7524 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7525 PyObject * obj0 = 0 ;
7526 char *kwnames[] = {
7527 (char *) "self", NULL
7528 };
7529
7530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7532 if (SWIG_arg_fail(1)) SWIG_fail;
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 delete arg1;
7536
7537 wxPyEndAllowThreads(__tstate);
7538 if (PyErr_Occurred()) SWIG_fail;
7539 }
7540 Py_INCREF(Py_None); resultobj = Py_None;
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj = NULL;
7549 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7550 PyObject * obj0 = 0 ;
7551 char *kwnames[] = {
7552 (char *) "self", NULL
7553 };
7554
7555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7557 if (SWIG_arg_fail(1)) SWIG_fail;
7558 {
7559 PyThreadState* __tstate = wxPyBeginAllowThreads();
7560 (arg1)->close();
7561
7562 wxPyEndAllowThreads(__tstate);
7563 if (PyErr_Occurred()) SWIG_fail;
7564 }
7565 Py_INCREF(Py_None); resultobj = Py_None;
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7573 PyObject *resultobj = NULL;
7574 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7575 PyObject * obj0 = 0 ;
7576 char *kwnames[] = {
7577 (char *) "self", NULL
7578 };
7579
7580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7582 if (SWIG_arg_fail(1)) SWIG_fail;
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 (arg1)->flush();
7586
7587 wxPyEndAllowThreads(__tstate);
7588 if (PyErr_Occurred()) SWIG_fail;
7589 }
7590 Py_INCREF(Py_None); resultobj = Py_None;
7591 return resultobj;
7592 fail:
7593 return NULL;
7594 }
7595
7596
7597 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7598 PyObject *resultobj = NULL;
7599 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7600 bool result;
7601 PyObject * obj0 = 0 ;
7602 char *kwnames[] = {
7603 (char *) "self", NULL
7604 };
7605
7606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7608 if (SWIG_arg_fail(1)) SWIG_fail;
7609 {
7610 PyThreadState* __tstate = wxPyBeginAllowThreads();
7611 result = (bool)(arg1)->eof();
7612
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = NULL;
7627 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7628 int arg2 = (int) -1 ;
7629 PyObject *result;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char *kwnames[] = {
7633 (char *) "self",(char *) "size", NULL
7634 };
7635
7636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7638 if (SWIG_arg_fail(1)) SWIG_fail;
7639 if (obj1) {
7640 {
7641 arg2 = static_cast<int >(SWIG_As_int(obj1));
7642 if (SWIG_arg_fail(2)) SWIG_fail;
7643 }
7644 }
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (PyObject *)(arg1)->read(arg2);
7648
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 resultobj = result;
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj = NULL;
7661 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7662 int arg2 = (int) -1 ;
7663 PyObject *result;
7664 PyObject * obj0 = 0 ;
7665 PyObject * obj1 = 0 ;
7666 char *kwnames[] = {
7667 (char *) "self",(char *) "size", NULL
7668 };
7669
7670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7672 if (SWIG_arg_fail(1)) SWIG_fail;
7673 if (obj1) {
7674 {
7675 arg2 = static_cast<int >(SWIG_As_int(obj1));
7676 if (SWIG_arg_fail(2)) SWIG_fail;
7677 }
7678 }
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 result = (PyObject *)(arg1)->readline(arg2);
7682
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 resultobj = result;
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7694 PyObject *resultobj = NULL;
7695 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7696 int arg2 = (int) -1 ;
7697 PyObject *result;
7698 PyObject * obj0 = 0 ;
7699 PyObject * obj1 = 0 ;
7700 char *kwnames[] = {
7701 (char *) "self",(char *) "sizehint", NULL
7702 };
7703
7704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7706 if (SWIG_arg_fail(1)) SWIG_fail;
7707 if (obj1) {
7708 {
7709 arg2 = static_cast<int >(SWIG_As_int(obj1));
7710 if (SWIG_arg_fail(2)) SWIG_fail;
7711 }
7712 }
7713 {
7714 PyThreadState* __tstate = wxPyBeginAllowThreads();
7715 result = (PyObject *)(arg1)->readlines(arg2);
7716
7717 wxPyEndAllowThreads(__tstate);
7718 if (PyErr_Occurred()) SWIG_fail;
7719 }
7720 resultobj = result;
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj = NULL;
7729 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7730 int arg2 ;
7731 int arg3 = (int) 0 ;
7732 PyObject * obj0 = 0 ;
7733 PyObject * obj1 = 0 ;
7734 PyObject * obj2 = 0 ;
7735 char *kwnames[] = {
7736 (char *) "self",(char *) "offset",(char *) "whence", NULL
7737 };
7738
7739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7741 if (SWIG_arg_fail(1)) SWIG_fail;
7742 {
7743 arg2 = static_cast<int >(SWIG_As_int(obj1));
7744 if (SWIG_arg_fail(2)) SWIG_fail;
7745 }
7746 if (obj2) {
7747 {
7748 arg3 = static_cast<int >(SWIG_As_int(obj2));
7749 if (SWIG_arg_fail(3)) SWIG_fail;
7750 }
7751 }
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 (arg1)->seek(arg2,arg3);
7755
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 Py_INCREF(Py_None); resultobj = Py_None;
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj = NULL;
7768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7769 int result;
7770 PyObject * obj0 = 0 ;
7771 char *kwnames[] = {
7772 (char *) "self", NULL
7773 };
7774
7775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7777 if (SWIG_arg_fail(1)) SWIG_fail;
7778 {
7779 PyThreadState* __tstate = wxPyBeginAllowThreads();
7780 result = (int)(arg1)->tell();
7781
7782 wxPyEndAllowThreads(__tstate);
7783 if (PyErr_Occurred()) SWIG_fail;
7784 }
7785 {
7786 resultobj = SWIG_From_int(static_cast<int >(result));
7787 }
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7795 PyObject *resultobj = NULL;
7796 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7797 char result;
7798 PyObject * obj0 = 0 ;
7799 char *kwnames[] = {
7800 (char *) "self", NULL
7801 };
7802
7803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7805 if (SWIG_arg_fail(1)) SWIG_fail;
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 result = (char)(arg1)->Peek();
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 {
7814 resultobj = SWIG_From_char(static_cast<char >(result));
7815 }
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj = NULL;
7824 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7825 char result;
7826 PyObject * obj0 = 0 ;
7827 char *kwnames[] = {
7828 (char *) "self", NULL
7829 };
7830
7831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7833 if (SWIG_arg_fail(1)) SWIG_fail;
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (char)(arg1)->GetC();
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = SWIG_From_char(static_cast<char >(result));
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = NULL;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 size_t result;
7854 PyObject * obj0 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "self", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (size_t)(arg1)->LastRead();
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 {
7870 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7871 }
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj = NULL;
7880 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7881 bool result;
7882 PyObject * obj0 = 0 ;
7883 char *kwnames[] = {
7884 (char *) "self", NULL
7885 };
7886
7887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(1)) SWIG_fail;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (bool)(arg1)->CanRead();
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 {
7898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7899 }
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7907 PyObject *resultobj = NULL;
7908 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7909 bool result;
7910 PyObject * obj0 = 0 ;
7911 char *kwnames[] = {
7912 (char *) "self", NULL
7913 };
7914
7915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7917 if (SWIG_arg_fail(1)) SWIG_fail;
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 result = (bool)(arg1)->Eof();
7921
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 {
7926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7927 }
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7935 PyObject *resultobj = NULL;
7936 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7937 char arg2 ;
7938 bool result;
7939 PyObject * obj0 = 0 ;
7940 PyObject * obj1 = 0 ;
7941 char *kwnames[] = {
7942 (char *) "self",(char *) "c", NULL
7943 };
7944
7945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7947 if (SWIG_arg_fail(1)) SWIG_fail;
7948 {
7949 arg2 = static_cast<char >(SWIG_As_char(obj1));
7950 if (SWIG_arg_fail(2)) SWIG_fail;
7951 }
7952 {
7953 PyThreadState* __tstate = wxPyBeginAllowThreads();
7954 result = (bool)(arg1)->Ungetch(arg2);
7955
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 {
7960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7961 }
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7969 PyObject *resultobj = NULL;
7970 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7971 long arg2 ;
7972 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7973 long result;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 PyObject * obj2 = 0 ;
7977 char *kwnames[] = {
7978 (char *) "self",(char *) "pos",(char *) "mode", NULL
7979 };
7980
7981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7983 if (SWIG_arg_fail(1)) SWIG_fail;
7984 {
7985 arg2 = static_cast<long >(SWIG_As_long(obj1));
7986 if (SWIG_arg_fail(2)) SWIG_fail;
7987 }
7988 if (obj2) {
7989 {
7990 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
7991 if (SWIG_arg_fail(3)) SWIG_fail;
7992 }
7993 }
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 result = (long)(arg1)->SeekI(arg2,arg3);
7997
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 {
8002 resultobj = SWIG_From_long(static_cast<long >(result));
8003 }
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj = NULL;
8012 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8013 long result;
8014 PyObject * obj0 = 0 ;
8015 char *kwnames[] = {
8016 (char *) "self", NULL
8017 };
8018
8019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8021 if (SWIG_arg_fail(1)) SWIG_fail;
8022 {
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 result = (long)(arg1)->TellI();
8025
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 {
8030 resultobj = SWIG_From_long(static_cast<long >(result));
8031 }
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8039 PyObject *obj;
8040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8041 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8042 Py_INCREF(obj);
8043 return Py_BuildValue((char *)"");
8044 }
8045 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8046 PyObject *resultobj = NULL;
8047 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8048 PyObject *arg2 = (PyObject *) 0 ;
8049 PyObject * obj0 = 0 ;
8050 PyObject * obj1 = 0 ;
8051 char *kwnames[] = {
8052 (char *) "self",(char *) "obj", NULL
8053 };
8054
8055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8057 if (SWIG_arg_fail(1)) SWIG_fail;
8058 arg2 = obj1;
8059 {
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 wxOutputStream_write(arg1,arg2);
8062
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 Py_INCREF(Py_None); resultobj = Py_None;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8074 PyObject *obj;
8075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8076 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8077 Py_INCREF(obj);
8078 return Py_BuildValue((char *)"");
8079 }
8080 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj = NULL;
8082 wxInputStream *arg1 = (wxInputStream *) 0 ;
8083 wxString *arg2 = 0 ;
8084 wxString *arg3 = 0 ;
8085 wxString *arg4 = 0 ;
8086 wxDateTime arg5 ;
8087 wxFSFile *result;
8088 wxPyInputStream *temp1 ;
8089 bool temp2 = false ;
8090 bool temp3 = false ;
8091 bool temp4 = false ;
8092 PyObject * obj0 = 0 ;
8093 PyObject * obj1 = 0 ;
8094 PyObject * obj2 = 0 ;
8095 PyObject * obj3 = 0 ;
8096 PyObject * obj4 = 0 ;
8097 char *kwnames[] = {
8098 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8099 };
8100
8101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8102 {
8103 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8104 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8105 } else {
8106 PyErr_Clear(); // clear the failure of the wxPyConvert above
8107 arg1 = wxPyCBInputStream_create(obj0, true);
8108 if (arg1 == NULL) {
8109 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8110 SWIG_fail;
8111 }
8112 }
8113 }
8114 {
8115 arg2 = wxString_in_helper(obj1);
8116 if (arg2 == NULL) SWIG_fail;
8117 temp2 = true;
8118 }
8119 {
8120 arg3 = wxString_in_helper(obj2);
8121 if (arg3 == NULL) SWIG_fail;
8122 temp3 = true;
8123 }
8124 {
8125 arg4 = wxString_in_helper(obj3);
8126 if (arg4 == NULL) SWIG_fail;
8127 temp4 = true;
8128 }
8129 {
8130 wxDateTime * argp;
8131 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8132 if (SWIG_arg_fail(5)) SWIG_fail;
8133 if (argp == NULL) {
8134 SWIG_null_ref("wxDateTime");
8135 }
8136 if (SWIG_arg_fail(5)) SWIG_fail;
8137 arg5 = *argp;
8138 }
8139 {
8140 PyThreadState* __tstate = wxPyBeginAllowThreads();
8141 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8142
8143 wxPyEndAllowThreads(__tstate);
8144 if (PyErr_Occurred()) SWIG_fail;
8145 }
8146 {
8147 resultobj = wxPyMake_wxObject(result, 1);
8148 }
8149 {
8150 if (temp2)
8151 delete arg2;
8152 }
8153 {
8154 if (temp3)
8155 delete arg3;
8156 }
8157 {
8158 if (temp4)
8159 delete arg4;
8160 }
8161 return resultobj;
8162 fail:
8163 {
8164 if (temp2)
8165 delete arg2;
8166 }
8167 {
8168 if (temp3)
8169 delete arg3;
8170 }
8171 {
8172 if (temp4)
8173 delete arg4;
8174 }
8175 return NULL;
8176 }
8177
8178
8179 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj = NULL;
8181 wxFSFile *arg1 = (wxFSFile *) 0 ;
8182 PyObject * obj0 = 0 ;
8183 char *kwnames[] = {
8184 (char *) "self", NULL
8185 };
8186
8187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8189 if (SWIG_arg_fail(1)) SWIG_fail;
8190 {
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 delete arg1;
8193
8194 wxPyEndAllowThreads(__tstate);
8195 if (PyErr_Occurred()) SWIG_fail;
8196 }
8197 Py_INCREF(Py_None); resultobj = Py_None;
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj = NULL;
8206 wxFSFile *arg1 = (wxFSFile *) 0 ;
8207 wxInputStream *result;
8208 PyObject * obj0 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "self", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8215 if (SWIG_arg_fail(1)) SWIG_fail;
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 result = (wxInputStream *)(arg1)->GetStream();
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 {
8224 wxPyInputStream * _ptr = NULL;
8225
8226 if (result) {
8227 _ptr = new wxPyInputStream(result);
8228 }
8229 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8230 }
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = NULL;
8239 wxFSFile *arg1 = (wxFSFile *) 0 ;
8240 wxString *result;
8241 PyObject * obj0 = 0 ;
8242 char *kwnames[] = {
8243 (char *) "self", NULL
8244 };
8245
8246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8248 if (SWIG_arg_fail(1)) SWIG_fail;
8249 {
8250 PyThreadState* __tstate = wxPyBeginAllowThreads();
8251 {
8252 wxString const &_result_ref = (arg1)->GetMimeType();
8253 result = (wxString *) &_result_ref;
8254 }
8255
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 {
8260 #if wxUSE_UNICODE
8261 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8262 #else
8263 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8264 #endif
8265 }
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj = NULL;
8274 wxFSFile *arg1 = (wxFSFile *) 0 ;
8275 wxString *result;
8276 PyObject * obj0 = 0 ;
8277 char *kwnames[] = {
8278 (char *) "self", NULL
8279 };
8280
8281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8283 if (SWIG_arg_fail(1)) SWIG_fail;
8284 {
8285 PyThreadState* __tstate = wxPyBeginAllowThreads();
8286 {
8287 wxString const &_result_ref = (arg1)->GetLocation();
8288 result = (wxString *) &_result_ref;
8289 }
8290
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 {
8295 #if wxUSE_UNICODE
8296 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8297 #else
8298 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8299 #endif
8300 }
8301 return resultobj;
8302 fail:
8303 return NULL;
8304 }
8305
8306
8307 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj = NULL;
8309 wxFSFile *arg1 = (wxFSFile *) 0 ;
8310 wxString *result;
8311 PyObject * obj0 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 {
8322 wxString const &_result_ref = (arg1)->GetAnchor();
8323 result = (wxString *) &_result_ref;
8324 }
8325
8326 wxPyEndAllowThreads(__tstate);
8327 if (PyErr_Occurred()) SWIG_fail;
8328 }
8329 {
8330 #if wxUSE_UNICODE
8331 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8332 #else
8333 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8334 #endif
8335 }
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj = NULL;
8344 wxFSFile *arg1 = (wxFSFile *) 0 ;
8345 wxDateTime result;
8346 PyObject * obj0 = 0 ;
8347 char *kwnames[] = {
8348 (char *) "self", NULL
8349 };
8350
8351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8353 if (SWIG_arg_fail(1)) SWIG_fail;
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = (arg1)->GetModificationTime();
8357
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 {
8362 wxDateTime * resultptr;
8363 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8365 }
8366 return resultobj;
8367 fail:
8368 return NULL;
8369 }
8370
8371
8372 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8373 PyObject *obj;
8374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8375 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8376 Py_INCREF(obj);
8377 return Py_BuildValue((char *)"");
8378 }
8379 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8380 PyObject *obj;
8381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8382 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8383 Py_INCREF(obj);
8384 return Py_BuildValue((char *)"");
8385 }
8386 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8387 PyObject *resultobj = NULL;
8388 wxPyFileSystemHandler *result;
8389 char *kwnames[] = {
8390 NULL
8391 };
8392
8393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8409 PyObject *resultobj = NULL;
8410 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8411 PyObject *arg2 = (PyObject *) 0 ;
8412 PyObject *arg3 = (PyObject *) 0 ;
8413 PyObject * obj0 = 0 ;
8414 PyObject * obj1 = 0 ;
8415 PyObject * obj2 = 0 ;
8416 char *kwnames[] = {
8417 (char *) "self",(char *) "self",(char *) "_class", NULL
8418 };
8419
8420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8422 if (SWIG_arg_fail(1)) SWIG_fail;
8423 arg2 = obj1;
8424 arg3 = obj2;
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 (arg1)->_setCallbackInfo(arg2,arg3);
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 Py_INCREF(Py_None); resultobj = Py_None;
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8440 PyObject *resultobj = NULL;
8441 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8442 wxString *arg2 = 0 ;
8443 bool result;
8444 bool temp2 = false ;
8445 PyObject * obj0 = 0 ;
8446 PyObject * obj1 = 0 ;
8447 char *kwnames[] = {
8448 (char *) "self",(char *) "location", NULL
8449 };
8450
8451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8453 if (SWIG_arg_fail(1)) SWIG_fail;
8454 {
8455 arg2 = wxString_in_helper(obj1);
8456 if (arg2 == NULL) SWIG_fail;
8457 temp2 = true;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 {
8467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8468 }
8469 {
8470 if (temp2)
8471 delete arg2;
8472 }
8473 return resultobj;
8474 fail:
8475 {
8476 if (temp2)
8477 delete arg2;
8478 }
8479 return NULL;
8480 }
8481
8482
8483 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8484 PyObject *resultobj = NULL;
8485 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8486 wxFileSystem *arg2 = 0 ;
8487 wxString *arg3 = 0 ;
8488 wxFSFile *result;
8489 bool temp3 = false ;
8490 PyObject * obj0 = 0 ;
8491 PyObject * obj1 = 0 ;
8492 PyObject * obj2 = 0 ;
8493 char *kwnames[] = {
8494 (char *) "self",(char *) "fs",(char *) "location", NULL
8495 };
8496
8497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8499 if (SWIG_arg_fail(1)) SWIG_fail;
8500 {
8501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8502 if (SWIG_arg_fail(2)) SWIG_fail;
8503 if (arg2 == NULL) {
8504 SWIG_null_ref("wxFileSystem");
8505 }
8506 if (SWIG_arg_fail(2)) SWIG_fail;
8507 }
8508 {
8509 arg3 = wxString_in_helper(obj2);
8510 if (arg3 == NULL) SWIG_fail;
8511 temp3 = true;
8512 }
8513 {
8514 PyThreadState* __tstate = wxPyBeginAllowThreads();
8515 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8516
8517 wxPyEndAllowThreads(__tstate);
8518 if (PyErr_Occurred()) SWIG_fail;
8519 }
8520 {
8521 resultobj = wxPyMake_wxObject(result, 1);
8522 }
8523 {
8524 if (temp3)
8525 delete arg3;
8526 }
8527 return resultobj;
8528 fail:
8529 {
8530 if (temp3)
8531 delete arg3;
8532 }
8533 return NULL;
8534 }
8535
8536
8537 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8538 PyObject *resultobj = NULL;
8539 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8540 wxString *arg2 = 0 ;
8541 int arg3 = (int) 0 ;
8542 wxString result;
8543 bool temp2 = false ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 PyObject * obj2 = 0 ;
8547 char *kwnames[] = {
8548 (char *) "self",(char *) "spec",(char *) "flags", NULL
8549 };
8550
8551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 {
8555 arg2 = wxString_in_helper(obj1);
8556 if (arg2 == NULL) SWIG_fail;
8557 temp2 = true;
8558 }
8559 if (obj2) {
8560 {
8561 arg3 = static_cast<int >(SWIG_As_int(obj2));
8562 if (SWIG_arg_fail(3)) SWIG_fail;
8563 }
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 {
8573 #if wxUSE_UNICODE
8574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8575 #else
8576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8577 #endif
8578 }
8579 {
8580 if (temp2)
8581 delete arg2;
8582 }
8583 return resultobj;
8584 fail:
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return NULL;
8590 }
8591
8592
8593 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj = NULL;
8595 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8596 wxString result;
8597 PyObject * obj0 = 0 ;
8598 char *kwnames[] = {
8599 (char *) "self", NULL
8600 };
8601
8602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8604 if (SWIG_arg_fail(1)) SWIG_fail;
8605 {
8606 PyThreadState* __tstate = wxPyBeginAllowThreads();
8607 result = (arg1)->FindNext();
8608
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 {
8613 #if wxUSE_UNICODE
8614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8615 #else
8616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8617 #endif
8618 }
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj = NULL;
8627 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8628 wxString *arg2 = 0 ;
8629 wxString result;
8630 bool temp2 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self",(char *) "location", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 arg2 = wxString_in_helper(obj1);
8642 if (arg2 == NULL) SWIG_fail;
8643 temp2 = true;
8644 }
8645 {
8646 PyThreadState* __tstate = wxPyBeginAllowThreads();
8647 result = (arg1)->GetProtocol((wxString const &)*arg2);
8648
8649 wxPyEndAllowThreads(__tstate);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 {
8653 #if wxUSE_UNICODE
8654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8655 #else
8656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8657 #endif
8658 }
8659 {
8660 if (temp2)
8661 delete arg2;
8662 }
8663 return resultobj;
8664 fail:
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj = NULL;
8675 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8676 wxString *arg2 = 0 ;
8677 wxString result;
8678 bool temp2 = false ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char *kwnames[] = {
8682 (char *) "self",(char *) "location", NULL
8683 };
8684
8685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8687 if (SWIG_arg_fail(1)) SWIG_fail;
8688 {
8689 arg2 = wxString_in_helper(obj1);
8690 if (arg2 == NULL) SWIG_fail;
8691 temp2 = true;
8692 }
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8696
8697 wxPyEndAllowThreads(__tstate);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 #if wxUSE_UNICODE
8702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8703 #else
8704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8705 #endif
8706 }
8707 {
8708 if (temp2)
8709 delete arg2;
8710 }
8711 return resultobj;
8712 fail:
8713 {
8714 if (temp2)
8715 delete arg2;
8716 }
8717 return NULL;
8718 }
8719
8720
8721 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8722 PyObject *resultobj = NULL;
8723 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8724 wxString *arg2 = 0 ;
8725 wxString result;
8726 bool temp2 = false ;
8727 PyObject * obj0 = 0 ;
8728 PyObject * obj1 = 0 ;
8729 char *kwnames[] = {
8730 (char *) "self",(char *) "location", NULL
8731 };
8732
8733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8735 if (SWIG_arg_fail(1)) SWIG_fail;
8736 {
8737 arg2 = wxString_in_helper(obj1);
8738 if (arg2 == NULL) SWIG_fail;
8739 temp2 = true;
8740 }
8741 {
8742 PyThreadState* __tstate = wxPyBeginAllowThreads();
8743 result = (arg1)->GetAnchor((wxString const &)*arg2);
8744
8745 wxPyEndAllowThreads(__tstate);
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 {
8749 #if wxUSE_UNICODE
8750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8751 #else
8752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8753 #endif
8754 }
8755 {
8756 if (temp2)
8757 delete arg2;
8758 }
8759 return resultobj;
8760 fail:
8761 {
8762 if (temp2)
8763 delete arg2;
8764 }
8765 return NULL;
8766 }
8767
8768
8769 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8770 PyObject *resultobj = NULL;
8771 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8772 wxString *arg2 = 0 ;
8773 wxString result;
8774 bool temp2 = false ;
8775 PyObject * obj0 = 0 ;
8776 PyObject * obj1 = 0 ;
8777 char *kwnames[] = {
8778 (char *) "self",(char *) "location", NULL
8779 };
8780
8781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8783 if (SWIG_arg_fail(1)) SWIG_fail;
8784 {
8785 arg2 = wxString_in_helper(obj1);
8786 if (arg2 == NULL) SWIG_fail;
8787 temp2 = true;
8788 }
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8792
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 {
8797 #if wxUSE_UNICODE
8798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8799 #else
8800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8801 #endif
8802 }
8803 {
8804 if (temp2)
8805 delete arg2;
8806 }
8807 return resultobj;
8808 fail:
8809 {
8810 if (temp2)
8811 delete arg2;
8812 }
8813 return NULL;
8814 }
8815
8816
8817 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8818 PyObject *resultobj = NULL;
8819 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8820 wxString *arg2 = 0 ;
8821 wxString result;
8822 bool temp2 = false ;
8823 PyObject * obj0 = 0 ;
8824 PyObject * obj1 = 0 ;
8825 char *kwnames[] = {
8826 (char *) "self",(char *) "location", NULL
8827 };
8828
8829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8831 if (SWIG_arg_fail(1)) SWIG_fail;
8832 {
8833 arg2 = wxString_in_helper(obj1);
8834 if (arg2 == NULL) SWIG_fail;
8835 temp2 = true;
8836 }
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8840
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 {
8845 #if wxUSE_UNICODE
8846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8847 #else
8848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8849 #endif
8850 }
8851 {
8852 if (temp2)
8853 delete arg2;
8854 }
8855 return resultobj;
8856 fail:
8857 {
8858 if (temp2)
8859 delete arg2;
8860 }
8861 return NULL;
8862 }
8863
8864
8865 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8866 PyObject *obj;
8867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8868 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8869 Py_INCREF(obj);
8870 return Py_BuildValue((char *)"");
8871 }
8872 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj = NULL;
8874 wxFileSystem *result;
8875 char *kwnames[] = {
8876 NULL
8877 };
8878
8879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8880 {
8881 PyThreadState* __tstate = wxPyBeginAllowThreads();
8882 result = (wxFileSystem *)new wxFileSystem();
8883
8884 wxPyEndAllowThreads(__tstate);
8885 if (PyErr_Occurred()) SWIG_fail;
8886 }
8887 {
8888 resultobj = wxPyMake_wxObject(result, 1);
8889 }
8890 return resultobj;
8891 fail:
8892 return NULL;
8893 }
8894
8895
8896 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8897 PyObject *resultobj = NULL;
8898 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8899 PyObject * obj0 = 0 ;
8900 char *kwnames[] = {
8901 (char *) "self", NULL
8902 };
8903
8904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8906 if (SWIG_arg_fail(1)) SWIG_fail;
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 delete arg1;
8910
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 Py_INCREF(Py_None); resultobj = Py_None;
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj = NULL;
8923 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8924 wxString *arg2 = 0 ;
8925 bool arg3 = (bool) false ;
8926 bool temp2 = false ;
8927 PyObject * obj0 = 0 ;
8928 PyObject * obj1 = 0 ;
8929 PyObject * obj2 = 0 ;
8930 char *kwnames[] = {
8931 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8932 };
8933
8934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8936 if (SWIG_arg_fail(1)) SWIG_fail;
8937 {
8938 arg2 = wxString_in_helper(obj1);
8939 if (arg2 == NULL) SWIG_fail;
8940 temp2 = true;
8941 }
8942 if (obj2) {
8943 {
8944 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8945 if (SWIG_arg_fail(3)) SWIG_fail;
8946 }
8947 }
8948 {
8949 PyThreadState* __tstate = wxPyBeginAllowThreads();
8950 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8951
8952 wxPyEndAllowThreads(__tstate);
8953 if (PyErr_Occurred()) SWIG_fail;
8954 }
8955 Py_INCREF(Py_None); resultobj = Py_None;
8956 {
8957 if (temp2)
8958 delete arg2;
8959 }
8960 return resultobj;
8961 fail:
8962 {
8963 if (temp2)
8964 delete arg2;
8965 }
8966 return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj = NULL;
8972 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8973 wxString result;
8974 PyObject * obj0 = 0 ;
8975 char *kwnames[] = {
8976 (char *) "self", NULL
8977 };
8978
8979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8981 if (SWIG_arg_fail(1)) SWIG_fail;
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 result = (arg1)->GetPath();
8985
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 {
8990 #if wxUSE_UNICODE
8991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8992 #else
8993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8994 #endif
8995 }
8996 return resultobj;
8997 fail:
8998 return NULL;
8999 }
9000
9001
9002 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9003 PyObject *resultobj = NULL;
9004 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9005 wxString *arg2 = 0 ;
9006 wxFSFile *result;
9007 bool temp2 = false ;
9008 PyObject * obj0 = 0 ;
9009 PyObject * obj1 = 0 ;
9010 char *kwnames[] = {
9011 (char *) "self",(char *) "location", NULL
9012 };
9013
9014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9016 if (SWIG_arg_fail(1)) SWIG_fail;
9017 {
9018 arg2 = wxString_in_helper(obj1);
9019 if (arg2 == NULL) SWIG_fail;
9020 temp2 = true;
9021 }
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 {
9030 resultobj = wxPyMake_wxObject(result, 1);
9031 }
9032 {
9033 if (temp2)
9034 delete arg2;
9035 }
9036 return resultobj;
9037 fail:
9038 {
9039 if (temp2)
9040 delete arg2;
9041 }
9042 return NULL;
9043 }
9044
9045
9046 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = NULL;
9048 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9049 wxString *arg2 = 0 ;
9050 int arg3 = (int) 0 ;
9051 wxString result;
9052 bool temp2 = false ;
9053 PyObject * obj0 = 0 ;
9054 PyObject * obj1 = 0 ;
9055 PyObject * obj2 = 0 ;
9056 char *kwnames[] = {
9057 (char *) "self",(char *) "spec",(char *) "flags", NULL
9058 };
9059
9060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9062 if (SWIG_arg_fail(1)) SWIG_fail;
9063 {
9064 arg2 = wxString_in_helper(obj1);
9065 if (arg2 == NULL) SWIG_fail;
9066 temp2 = true;
9067 }
9068 if (obj2) {
9069 {
9070 arg3 = static_cast<int >(SWIG_As_int(obj2));
9071 if (SWIG_arg_fail(3)) SWIG_fail;
9072 }
9073 }
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 {
9082 #if wxUSE_UNICODE
9083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9084 #else
9085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9086 #endif
9087 }
9088 {
9089 if (temp2)
9090 delete arg2;
9091 }
9092 return resultobj;
9093 fail:
9094 {
9095 if (temp2)
9096 delete arg2;
9097 }
9098 return NULL;
9099 }
9100
9101
9102 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9103 PyObject *resultobj = NULL;
9104 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9105 wxString result;
9106 PyObject * obj0 = 0 ;
9107 char *kwnames[] = {
9108 (char *) "self", NULL
9109 };
9110
9111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9113 if (SWIG_arg_fail(1)) SWIG_fail;
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = (arg1)->FindNext();
9117
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 {
9122 #if wxUSE_UNICODE
9123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9124 #else
9125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9126 #endif
9127 }
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9135 PyObject *resultobj = NULL;
9136 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9137 PyObject * obj0 = 0 ;
9138 char *kwnames[] = {
9139 (char *) "handler", NULL
9140 };
9141
9142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9144 if (SWIG_arg_fail(1)) SWIG_fail;
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 wxFileSystem::AddHandler(arg1);
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 Py_INCREF(Py_None); resultobj = Py_None;
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj = NULL;
9161 char *kwnames[] = {
9162 NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 wxFileSystem::CleanUpHandlers();
9169
9170 wxPyEndAllowThreads(__tstate);
9171 if (PyErr_Occurred()) SWIG_fail;
9172 }
9173 Py_INCREF(Py_None); resultobj = Py_None;
9174 return resultobj;
9175 fail:
9176 return NULL;
9177 }
9178
9179
9180 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9181 PyObject *resultobj = NULL;
9182 wxString *arg1 = 0 ;
9183 wxString result;
9184 bool temp1 = false ;
9185 PyObject * obj0 = 0 ;
9186 char *kwnames[] = {
9187 (char *) "filename", NULL
9188 };
9189
9190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9191 {
9192 arg1 = wxString_in_helper(obj0);
9193 if (arg1 == NULL) SWIG_fail;
9194 temp1 = true;
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9199
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 {
9204 #if wxUSE_UNICODE
9205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9206 #else
9207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9208 #endif
9209 }
9210 {
9211 if (temp1)
9212 delete arg1;
9213 }
9214 return resultobj;
9215 fail:
9216 {
9217 if (temp1)
9218 delete arg1;
9219 }
9220 return NULL;
9221 }
9222
9223
9224 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj = NULL;
9226 wxString *arg1 = 0 ;
9227 wxString result;
9228 bool temp1 = false ;
9229 PyObject * obj0 = 0 ;
9230 char *kwnames[] = {
9231 (char *) "url", NULL
9232 };
9233
9234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9235 {
9236 arg1 = wxString_in_helper(obj0);
9237 if (arg1 == NULL) SWIG_fail;
9238 temp1 = true;
9239 }
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9243
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 {
9248 #if wxUSE_UNICODE
9249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9250 #else
9251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9252 #endif
9253 }
9254 {
9255 if (temp1)
9256 delete arg1;
9257 }
9258 return resultobj;
9259 fail:
9260 {
9261 if (temp1)
9262 delete arg1;
9263 }
9264 return NULL;
9265 }
9266
9267
9268 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9269 PyObject *obj;
9270 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9271 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9272 Py_INCREF(obj);
9273 return Py_BuildValue((char *)"");
9274 }
9275 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj = NULL;
9277 wxInternetFSHandler *result;
9278 char *kwnames[] = {
9279 NULL
9280 };
9281
9282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9286
9287 wxPyEndAllowThreads(__tstate);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9291 return resultobj;
9292 fail:
9293 return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj = NULL;
9299 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9300 wxString *arg2 = 0 ;
9301 bool result;
9302 bool temp2 = false ;
9303 PyObject * obj0 = 0 ;
9304 PyObject * obj1 = 0 ;
9305 char *kwnames[] = {
9306 (char *) "self",(char *) "location", NULL
9307 };
9308
9309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9311 if (SWIG_arg_fail(1)) SWIG_fail;
9312 {
9313 arg2 = wxString_in_helper(obj1);
9314 if (arg2 == NULL) SWIG_fail;
9315 temp2 = true;
9316 }
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 {
9325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9326 }
9327 {
9328 if (temp2)
9329 delete arg2;
9330 }
9331 return resultobj;
9332 fail:
9333 {
9334 if (temp2)
9335 delete arg2;
9336 }
9337 return NULL;
9338 }
9339
9340
9341 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9342 PyObject *resultobj = NULL;
9343 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9344 wxFileSystem *arg2 = 0 ;
9345 wxString *arg3 = 0 ;
9346 wxFSFile *result;
9347 bool temp3 = false ;
9348 PyObject * obj0 = 0 ;
9349 PyObject * obj1 = 0 ;
9350 PyObject * obj2 = 0 ;
9351 char *kwnames[] = {
9352 (char *) "self",(char *) "fs",(char *) "location", NULL
9353 };
9354
9355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9357 if (SWIG_arg_fail(1)) SWIG_fail;
9358 {
9359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9360 if (SWIG_arg_fail(2)) SWIG_fail;
9361 if (arg2 == NULL) {
9362 SWIG_null_ref("wxFileSystem");
9363 }
9364 if (SWIG_arg_fail(2)) SWIG_fail;
9365 }
9366 {
9367 arg3 = wxString_in_helper(obj2);
9368 if (arg3 == NULL) SWIG_fail;
9369 temp3 = true;
9370 }
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9374
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 resultobj = wxPyMake_wxObject(result, 1);
9380 }
9381 {
9382 if (temp3)
9383 delete arg3;
9384 }
9385 return resultobj;
9386 fail:
9387 {
9388 if (temp3)
9389 delete arg3;
9390 }
9391 return NULL;
9392 }
9393
9394
9395 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9396 PyObject *obj;
9397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9398 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9399 Py_INCREF(obj);
9400 return Py_BuildValue((char *)"");
9401 }
9402 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj = NULL;
9404 wxZipFSHandler *result;
9405 char *kwnames[] = {
9406 NULL
9407 };
9408
9409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 result = (wxZipFSHandler *)new wxZipFSHandler();
9413
9414 wxPyEndAllowThreads(__tstate);
9415 if (PyErr_Occurred()) SWIG_fail;
9416 }
9417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9418 return resultobj;
9419 fail:
9420 return NULL;
9421 }
9422
9423
9424 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9425 PyObject *resultobj = NULL;
9426 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9427 wxString *arg2 = 0 ;
9428 bool result;
9429 bool temp2 = false ;
9430 PyObject * obj0 = 0 ;
9431 PyObject * obj1 = 0 ;
9432 char *kwnames[] = {
9433 (char *) "self",(char *) "location", NULL
9434 };
9435
9436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9438 if (SWIG_arg_fail(1)) SWIG_fail;
9439 {
9440 arg2 = wxString_in_helper(obj1);
9441 if (arg2 == NULL) SWIG_fail;
9442 temp2 = true;
9443 }
9444 {
9445 PyThreadState* __tstate = wxPyBeginAllowThreads();
9446 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9447
9448 wxPyEndAllowThreads(__tstate);
9449 if (PyErr_Occurred()) SWIG_fail;
9450 }
9451 {
9452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9453 }
9454 {
9455 if (temp2)
9456 delete arg2;
9457 }
9458 return resultobj;
9459 fail:
9460 {
9461 if (temp2)
9462 delete arg2;
9463 }
9464 return NULL;
9465 }
9466
9467
9468 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9469 PyObject *resultobj = NULL;
9470 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9471 wxFileSystem *arg2 = 0 ;
9472 wxString *arg3 = 0 ;
9473 wxFSFile *result;
9474 bool temp3 = false ;
9475 PyObject * obj0 = 0 ;
9476 PyObject * obj1 = 0 ;
9477 PyObject * obj2 = 0 ;
9478 char *kwnames[] = {
9479 (char *) "self",(char *) "fs",(char *) "location", NULL
9480 };
9481
9482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9484 if (SWIG_arg_fail(1)) SWIG_fail;
9485 {
9486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9487 if (SWIG_arg_fail(2)) SWIG_fail;
9488 if (arg2 == NULL) {
9489 SWIG_null_ref("wxFileSystem");
9490 }
9491 if (SWIG_arg_fail(2)) SWIG_fail;
9492 }
9493 {
9494 arg3 = wxString_in_helper(obj2);
9495 if (arg3 == NULL) SWIG_fail;
9496 temp3 = true;
9497 }
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9501
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 {
9506 resultobj = wxPyMake_wxObject(result, 1);
9507 }
9508 {
9509 if (temp3)
9510 delete arg3;
9511 }
9512 return resultobj;
9513 fail:
9514 {
9515 if (temp3)
9516 delete arg3;
9517 }
9518 return NULL;
9519 }
9520
9521
9522 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9523 PyObject *resultobj = NULL;
9524 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9525 wxString *arg2 = 0 ;
9526 int arg3 = (int) 0 ;
9527 wxString result;
9528 bool temp2 = false ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 PyObject * obj2 = 0 ;
9532 char *kwnames[] = {
9533 (char *) "self",(char *) "spec",(char *) "flags", NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(1)) SWIG_fail;
9539 {
9540 arg2 = wxString_in_helper(obj1);
9541 if (arg2 == NULL) SWIG_fail;
9542 temp2 = true;
9543 }
9544 if (obj2) {
9545 {
9546 arg3 = static_cast<int >(SWIG_As_int(obj2));
9547 if (SWIG_arg_fail(3)) SWIG_fail;
9548 }
9549 }
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9553
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 {
9558 #if wxUSE_UNICODE
9559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9560 #else
9561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9562 #endif
9563 }
9564 {
9565 if (temp2)
9566 delete arg2;
9567 }
9568 return resultobj;
9569 fail:
9570 {
9571 if (temp2)
9572 delete arg2;
9573 }
9574 return NULL;
9575 }
9576
9577
9578 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9579 PyObject *resultobj = NULL;
9580 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9581 wxString result;
9582 PyObject * obj0 = 0 ;
9583 char *kwnames[] = {
9584 (char *) "self", NULL
9585 };
9586
9587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9589 if (SWIG_arg_fail(1)) SWIG_fail;
9590 {
9591 PyThreadState* __tstate = wxPyBeginAllowThreads();
9592 result = (arg1)->FindNext();
9593
9594 wxPyEndAllowThreads(__tstate);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 {
9598 #if wxUSE_UNICODE
9599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9600 #else
9601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9602 #endif
9603 }
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9611 PyObject *obj;
9612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9613 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9614 Py_INCREF(obj);
9615 return Py_BuildValue((char *)"");
9616 }
9617 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9618 PyObject *resultobj = NULL;
9619 wxString *arg1 = 0 ;
9620 wxImage *arg2 = 0 ;
9621 long arg3 ;
9622 bool temp1 = false ;
9623 PyObject * obj0 = 0 ;
9624 PyObject * obj1 = 0 ;
9625 PyObject * obj2 = 0 ;
9626 char *kwnames[] = {
9627 (char *) "filename",(char *) "image",(char *) "type", NULL
9628 };
9629
9630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9631 {
9632 arg1 = wxString_in_helper(obj0);
9633 if (arg1 == NULL) SWIG_fail;
9634 temp1 = true;
9635 }
9636 {
9637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9638 if (SWIG_arg_fail(2)) SWIG_fail;
9639 if (arg2 == NULL) {
9640 SWIG_null_ref("wxImage");
9641 }
9642 if (SWIG_arg_fail(2)) SWIG_fail;
9643 }
9644 {
9645 arg3 = static_cast<long >(SWIG_As_long(obj2));
9646 if (SWIG_arg_fail(3)) SWIG_fail;
9647 }
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9651
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 Py_INCREF(Py_None); resultobj = Py_None;
9656 {
9657 if (temp1)
9658 delete arg1;
9659 }
9660 return resultobj;
9661 fail:
9662 {
9663 if (temp1)
9664 delete arg1;
9665 }
9666 return NULL;
9667 }
9668
9669
9670 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9671 PyObject *resultobj = NULL;
9672 wxString *arg1 = 0 ;
9673 wxBitmap *arg2 = 0 ;
9674 long arg3 ;
9675 bool temp1 = false ;
9676 PyObject * obj0 = 0 ;
9677 PyObject * obj1 = 0 ;
9678 PyObject * obj2 = 0 ;
9679 char *kwnames[] = {
9680 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9681 };
9682
9683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9684 {
9685 arg1 = wxString_in_helper(obj0);
9686 if (arg1 == NULL) SWIG_fail;
9687 temp1 = true;
9688 }
9689 {
9690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9691 if (SWIG_arg_fail(2)) SWIG_fail;
9692 if (arg2 == NULL) {
9693 SWIG_null_ref("wxBitmap");
9694 }
9695 if (SWIG_arg_fail(2)) SWIG_fail;
9696 }
9697 {
9698 arg3 = static_cast<long >(SWIG_As_long(obj2));
9699 if (SWIG_arg_fail(3)) SWIG_fail;
9700 }
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9704
9705 wxPyEndAllowThreads(__tstate);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 Py_INCREF(Py_None); resultobj = Py_None;
9709 {
9710 if (temp1)
9711 delete arg1;
9712 }
9713 return resultobj;
9714 fail:
9715 {
9716 if (temp1)
9717 delete arg1;
9718 }
9719 return NULL;
9720 }
9721
9722
9723 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj = NULL;
9725 wxString *arg1 = 0 ;
9726 PyObject *arg2 = (PyObject *) 0 ;
9727 bool temp1 = false ;
9728 PyObject * obj0 = 0 ;
9729 PyObject * obj1 = 0 ;
9730 char *kwnames[] = {
9731 (char *) "filename",(char *) "data", NULL
9732 };
9733
9734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9735 {
9736 arg1 = wxString_in_helper(obj0);
9737 if (arg1 == NULL) SWIG_fail;
9738 temp1 = true;
9739 }
9740 arg2 = obj1;
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9744
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 Py_INCREF(Py_None); resultobj = Py_None;
9749 {
9750 if (temp1)
9751 delete arg1;
9752 }
9753 return resultobj;
9754 fail:
9755 {
9756 if (temp1)
9757 delete arg1;
9758 }
9759 return NULL;
9760 }
9761
9762
9763 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj = NULL;
9765 wxMemoryFSHandler *result;
9766 char *kwnames[] = {
9767 NULL
9768 };
9769
9770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9771 {
9772 PyThreadState* __tstate = wxPyBeginAllowThreads();
9773 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9774
9775 wxPyEndAllowThreads(__tstate);
9776 if (PyErr_Occurred()) SWIG_fail;
9777 }
9778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj = NULL;
9787 wxString *arg1 = 0 ;
9788 bool temp1 = false ;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "filename", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9795 {
9796 arg1 = wxString_in_helper(obj0);
9797 if (arg1 == NULL) SWIG_fail;
9798 temp1 = true;
9799 }
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 Py_INCREF(Py_None); resultobj = Py_None;
9808 {
9809 if (temp1)
9810 delete arg1;
9811 }
9812 return resultobj;
9813 fail:
9814 {
9815 if (temp1)
9816 delete arg1;
9817 }
9818 return NULL;
9819 }
9820
9821
9822 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9823 PyObject *resultobj = NULL;
9824 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9825 wxString *arg2 = 0 ;
9826 bool result;
9827 bool temp2 = false ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self",(char *) "location", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 {
9838 arg2 = wxString_in_helper(obj1);
9839 if (arg2 == NULL) SWIG_fail;
9840 temp2 = true;
9841 }
9842 {
9843 PyThreadState* __tstate = wxPyBeginAllowThreads();
9844 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9845
9846 wxPyEndAllowThreads(__tstate);
9847 if (PyErr_Occurred()) SWIG_fail;
9848 }
9849 {
9850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9851 }
9852 {
9853 if (temp2)
9854 delete arg2;
9855 }
9856 return resultobj;
9857 fail:
9858 {
9859 if (temp2)
9860 delete arg2;
9861 }
9862 return NULL;
9863 }
9864
9865
9866 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9867 PyObject *resultobj = NULL;
9868 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9869 wxFileSystem *arg2 = 0 ;
9870 wxString *arg3 = 0 ;
9871 wxFSFile *result;
9872 bool temp3 = false ;
9873 PyObject * obj0 = 0 ;
9874 PyObject * obj1 = 0 ;
9875 PyObject * obj2 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self",(char *) "fs",(char *) "location", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9885 if (SWIG_arg_fail(2)) SWIG_fail;
9886 if (arg2 == NULL) {
9887 SWIG_null_ref("wxFileSystem");
9888 }
9889 if (SWIG_arg_fail(2)) SWIG_fail;
9890 }
9891 {
9892 arg3 = wxString_in_helper(obj2);
9893 if (arg3 == NULL) SWIG_fail;
9894 temp3 = true;
9895 }
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 {
9904 resultobj = wxPyMake_wxObject(result, 1);
9905 }
9906 {
9907 if (temp3)
9908 delete arg3;
9909 }
9910 return resultobj;
9911 fail:
9912 {
9913 if (temp3)
9914 delete arg3;
9915 }
9916 return NULL;
9917 }
9918
9919
9920 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9921 PyObject *resultobj = NULL;
9922 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9923 wxString *arg2 = 0 ;
9924 int arg3 = (int) 0 ;
9925 wxString result;
9926 bool temp2 = false ;
9927 PyObject * obj0 = 0 ;
9928 PyObject * obj1 = 0 ;
9929 PyObject * obj2 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "self",(char *) "spec",(char *) "flags", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9936 if (SWIG_arg_fail(1)) SWIG_fail;
9937 {
9938 arg2 = wxString_in_helper(obj1);
9939 if (arg2 == NULL) SWIG_fail;
9940 temp2 = true;
9941 }
9942 if (obj2) {
9943 {
9944 arg3 = static_cast<int >(SWIG_As_int(obj2));
9945 if (SWIG_arg_fail(3)) SWIG_fail;
9946 }
9947 }
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9951
9952 wxPyEndAllowThreads(__tstate);
9953 if (PyErr_Occurred()) SWIG_fail;
9954 }
9955 {
9956 #if wxUSE_UNICODE
9957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9958 #else
9959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9960 #endif
9961 }
9962 {
9963 if (temp2)
9964 delete arg2;
9965 }
9966 return resultobj;
9967 fail:
9968 {
9969 if (temp2)
9970 delete arg2;
9971 }
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj = NULL;
9978 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9979 wxString result;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "self", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9987 if (SWIG_arg_fail(1)) SWIG_fail;
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 result = (arg1)->FindNext();
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 {
9996 #if wxUSE_UNICODE
9997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9998 #else
9999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10000 #endif
10001 }
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10009 PyObject *obj;
10010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10011 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10012 Py_INCREF(obj);
10013 return Py_BuildValue((char *)"");
10014 }
10015 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10016 PyObject *resultobj = NULL;
10017 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10018 wxString result;
10019 PyObject * obj0 = 0 ;
10020 char *kwnames[] = {
10021 (char *) "self", NULL
10022 };
10023
10024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10026 if (SWIG_arg_fail(1)) SWIG_fail;
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 result = (arg1)->GetName();
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 {
10035 #if wxUSE_UNICODE
10036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10037 #else
10038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10039 #endif
10040 }
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj = NULL;
10049 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10050 wxString result;
10051 PyObject * obj0 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "self", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10058 if (SWIG_arg_fail(1)) SWIG_fail;
10059 {
10060 PyThreadState* __tstate = wxPyBeginAllowThreads();
10061 result = (arg1)->GetExtension();
10062
10063 wxPyEndAllowThreads(__tstate);
10064 if (PyErr_Occurred()) SWIG_fail;
10065 }
10066 {
10067 #if wxUSE_UNICODE
10068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10069 #else
10070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10071 #endif
10072 }
10073 return resultobj;
10074 fail:
10075 return NULL;
10076 }
10077
10078
10079 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj = NULL;
10081 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10082 long result;
10083 PyObject * obj0 = 0 ;
10084 char *kwnames[] = {
10085 (char *) "self", NULL
10086 };
10087
10088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10090 if (SWIG_arg_fail(1)) SWIG_fail;
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 result = (long)(arg1)->GetType();
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 {
10099 resultobj = SWIG_From_long(static_cast<long >(result));
10100 }
10101 return resultobj;
10102 fail:
10103 return NULL;
10104 }
10105
10106
10107 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10108 PyObject *resultobj = NULL;
10109 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10110 wxString result;
10111 PyObject * obj0 = 0 ;
10112 char *kwnames[] = {
10113 (char *) "self", NULL
10114 };
10115
10116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10118 if (SWIG_arg_fail(1)) SWIG_fail;
10119 {
10120 PyThreadState* __tstate = wxPyBeginAllowThreads();
10121 result = (arg1)->GetMimeType();
10122
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 {
10127 #if wxUSE_UNICODE
10128 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10129 #else
10130 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10131 #endif
10132 }
10133 return resultobj;
10134 fail:
10135 return NULL;
10136 }
10137
10138
10139 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10140 PyObject *resultobj = NULL;
10141 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10142 wxString *arg2 = 0 ;
10143 bool result;
10144 bool temp2 = false ;
10145 PyObject * obj0 = 0 ;
10146 PyObject * obj1 = 0 ;
10147 char *kwnames[] = {
10148 (char *) "self",(char *) "name", NULL
10149 };
10150
10151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10153 if (SWIG_arg_fail(1)) SWIG_fail;
10154 {
10155 arg2 = wxString_in_helper(obj1);
10156 if (arg2 == NULL) SWIG_fail;
10157 temp2 = true;
10158 }
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10162
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 {
10167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10168 }
10169 {
10170 if (temp2)
10171 delete arg2;
10172 }
10173 return resultobj;
10174 fail:
10175 {
10176 if (temp2)
10177 delete arg2;
10178 }
10179 return NULL;
10180 }
10181
10182
10183 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10184 PyObject *resultobj = NULL;
10185 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10186 wxString *arg2 = 0 ;
10187 bool temp2 = false ;
10188 PyObject * obj0 = 0 ;
10189 PyObject * obj1 = 0 ;
10190 char *kwnames[] = {
10191 (char *) "self",(char *) "name", NULL
10192 };
10193
10194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10196 if (SWIG_arg_fail(1)) SWIG_fail;
10197 {
10198 arg2 = wxString_in_helper(obj1);
10199 if (arg2 == NULL) SWIG_fail;
10200 temp2 = true;
10201 }
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 (arg1)->SetName((wxString const &)*arg2);
10205
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 Py_INCREF(Py_None); resultobj = Py_None;
10210 {
10211 if (temp2)
10212 delete arg2;
10213 }
10214 return resultobj;
10215 fail:
10216 {
10217 if (temp2)
10218 delete arg2;
10219 }
10220 return NULL;
10221 }
10222
10223
10224 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10225 PyObject *resultobj = NULL;
10226 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10227 wxString *arg2 = 0 ;
10228 bool temp2 = false ;
10229 PyObject * obj0 = 0 ;
10230 PyObject * obj1 = 0 ;
10231 char *kwnames[] = {
10232 (char *) "self",(char *) "extension", NULL
10233 };
10234
10235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10237 if (SWIG_arg_fail(1)) SWIG_fail;
10238 {
10239 arg2 = wxString_in_helper(obj1);
10240 if (arg2 == NULL) SWIG_fail;
10241 temp2 = true;
10242 }
10243 {
10244 PyThreadState* __tstate = wxPyBeginAllowThreads();
10245 (arg1)->SetExtension((wxString const &)*arg2);
10246
10247 wxPyEndAllowThreads(__tstate);
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 Py_INCREF(Py_None); resultobj = Py_None;
10251 {
10252 if (temp2)
10253 delete arg2;
10254 }
10255 return resultobj;
10256 fail:
10257 {
10258 if (temp2)
10259 delete arg2;
10260 }
10261 return NULL;
10262 }
10263
10264
10265 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10266 PyObject *resultobj = NULL;
10267 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10268 long arg2 ;
10269 PyObject * obj0 = 0 ;
10270 PyObject * obj1 = 0 ;
10271 char *kwnames[] = {
10272 (char *) "self",(char *) "type", NULL
10273 };
10274
10275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10277 if (SWIG_arg_fail(1)) SWIG_fail;
10278 {
10279 arg2 = static_cast<long >(SWIG_As_long(obj1));
10280 if (SWIG_arg_fail(2)) SWIG_fail;
10281 }
10282 {
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 (arg1)->SetType(arg2);
10285
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 Py_INCREF(Py_None); resultobj = Py_None;
10290 return resultobj;
10291 fail:
10292 return NULL;
10293 }
10294
10295
10296 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj = NULL;
10298 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10299 wxString *arg2 = 0 ;
10300 bool temp2 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self",(char *) "mimetype", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 {
10311 arg2 = wxString_in_helper(obj1);
10312 if (arg2 == NULL) SWIG_fail;
10313 temp2 = true;
10314 }
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 (arg1)->SetMimeType((wxString const &)*arg2);
10318
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 Py_INCREF(Py_None); resultobj = Py_None;
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return resultobj;
10328 fail:
10329 {
10330 if (temp2)
10331 delete arg2;
10332 }
10333 return NULL;
10334 }
10335
10336
10337 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10338 PyObject *obj;
10339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10340 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10341 Py_INCREF(obj);
10342 return Py_BuildValue((char *)"");
10343 }
10344 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj = NULL;
10346 wxPyImageHandler *result;
10347 char *kwnames[] = {
10348 NULL
10349 };
10350
10351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10352 {
10353 PyThreadState* __tstate = wxPyBeginAllowThreads();
10354 result = (wxPyImageHandler *)new wxPyImageHandler();
10355
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10360 return resultobj;
10361 fail:
10362 return NULL;
10363 }
10364
10365
10366 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10367 PyObject *resultobj = NULL;
10368 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10369 PyObject *arg2 = (PyObject *) 0 ;
10370 PyObject * obj0 = 0 ;
10371 PyObject * obj1 = 0 ;
10372 char *kwnames[] = {
10373 (char *) "self",(char *) "self", NULL
10374 };
10375
10376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10378 if (SWIG_arg_fail(1)) SWIG_fail;
10379 arg2 = obj1;
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 (arg1)->_SetSelf(arg2);
10383
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 Py_INCREF(Py_None); resultobj = Py_None;
10388 return resultobj;
10389 fail:
10390 return NULL;
10391 }
10392
10393
10394 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10395 PyObject *obj;
10396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10397 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10398 Py_INCREF(obj);
10399 return Py_BuildValue((char *)"");
10400 }
10401 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj = NULL;
10403 wxImageHistogram *result;
10404 char *kwnames[] = {
10405 NULL
10406 };
10407
10408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10409 {
10410 PyThreadState* __tstate = wxPyBeginAllowThreads();
10411 result = (wxImageHistogram *)new wxImageHistogram();
10412
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = NULL;
10425 byte arg1 ;
10426 byte arg2 ;
10427 byte arg3 ;
10428 unsigned long result;
10429 PyObject * obj0 = 0 ;
10430 PyObject * obj1 = 0 ;
10431 PyObject * obj2 = 0 ;
10432 char *kwnames[] = {
10433 (char *) "r",(char *) "g",(char *) "b", NULL
10434 };
10435
10436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10437 {
10438 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10439 if (SWIG_arg_fail(1)) SWIG_fail;
10440 }
10441 {
10442 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10443 if (SWIG_arg_fail(2)) SWIG_fail;
10444 }
10445 {
10446 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10447 if (SWIG_arg_fail(3)) SWIG_fail;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 {
10457 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10458 }
10459 return resultobj;
10460 fail:
10461 return NULL;
10462 }
10463
10464
10465 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10466 PyObject *resultobj = NULL;
10467 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10468 byte *arg2 = (byte *) 0 ;
10469 byte *arg3 = (byte *) 0 ;
10470 byte *arg4 = (byte *) 0 ;
10471 byte arg5 = (byte) 1 ;
10472 byte arg6 = (byte) 0 ;
10473 byte arg7 = (byte) 0 ;
10474 bool result;
10475 byte temp2 ;
10476 int res2 = 0 ;
10477 byte temp3 ;
10478 int res3 = 0 ;
10479 byte temp4 ;
10480 int res4 = 0 ;
10481 PyObject * obj0 = 0 ;
10482 PyObject * obj1 = 0 ;
10483 PyObject * obj2 = 0 ;
10484 PyObject * obj3 = 0 ;
10485 char *kwnames[] = {
10486 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10487 };
10488
10489 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10490 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10491 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10494 if (SWIG_arg_fail(1)) SWIG_fail;
10495 if (obj1) {
10496 {
10497 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10498 if (SWIG_arg_fail(5)) SWIG_fail;
10499 }
10500 }
10501 if (obj2) {
10502 {
10503 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10504 if (SWIG_arg_fail(6)) SWIG_fail;
10505 }
10506 }
10507 if (obj3) {
10508 {
10509 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10510 if (SWIG_arg_fail(7)) SWIG_fail;
10511 }
10512 }
10513 {
10514 PyThreadState* __tstate = wxPyBeginAllowThreads();
10515 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10516
10517 wxPyEndAllowThreads(__tstate);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 {
10521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10522 }
10523 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10524 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10525 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10526 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10527 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10528 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10529 return resultobj;
10530 fail:
10531 return NULL;
10532 }
10533
10534
10535 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10536 PyObject *resultobj = NULL;
10537 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10538 unsigned long arg2 ;
10539 unsigned long result;
10540 PyObject * obj0 = 0 ;
10541 PyObject * obj1 = 0 ;
10542 char *kwnames[] = {
10543 (char *) "self",(char *) "key", NULL
10544 };
10545
10546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10548 if (SWIG_arg_fail(1)) SWIG_fail;
10549 {
10550 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10551 if (SWIG_arg_fail(2)) SWIG_fail;
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10556
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 {
10561 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10562 }
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj = NULL;
10571 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10572 byte arg2 ;
10573 byte arg3 ;
10574 byte arg4 ;
10575 unsigned long result;
10576 PyObject * obj0 = 0 ;
10577 PyObject * obj1 = 0 ;
10578 PyObject * obj2 = 0 ;
10579 PyObject * obj3 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10586 if (SWIG_arg_fail(1)) SWIG_fail;
10587 {
10588 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10589 if (SWIG_arg_fail(2)) SWIG_fail;
10590 }
10591 {
10592 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10593 if (SWIG_arg_fail(3)) SWIG_fail;
10594 }
10595 {
10596 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10597 if (SWIG_arg_fail(4)) SWIG_fail;
10598 }
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10602
10603 wxPyEndAllowThreads(__tstate);
10604 if (PyErr_Occurred()) SWIG_fail;
10605 }
10606 {
10607 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10608 }
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10616 PyObject *resultobj = NULL;
10617 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10618 wxColour *arg2 = 0 ;
10619 unsigned long result;
10620 wxColour temp2 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "self",(char *) "colour", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 {
10631 arg2 = &temp2;
10632 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10633 }
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 {
10642 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10643 }
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10651 PyObject *obj;
10652 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10653 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10654 Py_INCREF(obj);
10655 return Py_BuildValue((char *)"");
10656 }
10657 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10658 PyObject *resultobj = NULL;
10659 byte arg1 = (byte) 0 ;
10660 byte arg2 = (byte) 0 ;
10661 byte arg3 = (byte) 0 ;
10662 wxImage_RGBValue *result;
10663 PyObject * obj0 = 0 ;
10664 PyObject * obj1 = 0 ;
10665 PyObject * obj2 = 0 ;
10666 char *kwnames[] = {
10667 (char *) "r",(char *) "g",(char *) "b", NULL
10668 };
10669
10670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10671 if (obj0) {
10672 {
10673 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10674 if (SWIG_arg_fail(1)) SWIG_fail;
10675 }
10676 }
10677 if (obj1) {
10678 {
10679 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10680 if (SWIG_arg_fail(2)) SWIG_fail;
10681 }
10682 }
10683 if (obj2) {
10684 {
10685 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10686 if (SWIG_arg_fail(3)) SWIG_fail;
10687 }
10688 }
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10692
10693 wxPyEndAllowThreads(__tstate);
10694 if (PyErr_Occurred()) SWIG_fail;
10695 }
10696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10697 return resultobj;
10698 fail:
10699 return NULL;
10700 }
10701
10702
10703 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10704 PyObject *resultobj = NULL;
10705 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10706 byte arg2 ;
10707 PyObject * obj0 = 0 ;
10708 PyObject * obj1 = 0 ;
10709 char *kwnames[] = {
10710 (char *) "self",(char *) "red", NULL
10711 };
10712
10713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10715 if (SWIG_arg_fail(1)) SWIG_fail;
10716 {
10717 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10718 if (SWIG_arg_fail(2)) SWIG_fail;
10719 }
10720 if (arg1) (arg1)->red = arg2;
10721
10722 Py_INCREF(Py_None); resultobj = Py_None;
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = NULL;
10731 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10732 byte result;
10733 PyObject * obj0 = 0 ;
10734 char *kwnames[] = {
10735 (char *) "self", NULL
10736 };
10737
10738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10740 if (SWIG_arg_fail(1)) SWIG_fail;
10741 result = (byte) ((arg1)->red);
10742
10743 {
10744 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10745 }
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj = NULL;
10754 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10755 byte arg2 ;
10756 PyObject * obj0 = 0 ;
10757 PyObject * obj1 = 0 ;
10758 char *kwnames[] = {
10759 (char *) "self",(char *) "green", NULL
10760 };
10761
10762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10764 if (SWIG_arg_fail(1)) SWIG_fail;
10765 {
10766 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10767 if (SWIG_arg_fail(2)) SWIG_fail;
10768 }
10769 if (arg1) (arg1)->green = arg2;
10770
10771 Py_INCREF(Py_None); resultobj = Py_None;
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj = NULL;
10780 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10781 byte result;
10782 PyObject * obj0 = 0 ;
10783 char *kwnames[] = {
10784 (char *) "self", NULL
10785 };
10786
10787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10789 if (SWIG_arg_fail(1)) SWIG_fail;
10790 result = (byte) ((arg1)->green);
10791
10792 {
10793 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10794 }
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj = NULL;
10803 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10804 byte arg2 ;
10805 PyObject * obj0 = 0 ;
10806 PyObject * obj1 = 0 ;
10807 char *kwnames[] = {
10808 (char *) "self",(char *) "blue", NULL
10809 };
10810
10811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 {
10815 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10816 if (SWIG_arg_fail(2)) SWIG_fail;
10817 }
10818 if (arg1) (arg1)->blue = arg2;
10819
10820 Py_INCREF(Py_None); resultobj = Py_None;
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = NULL;
10829 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10830 byte result;
10831 PyObject * obj0 = 0 ;
10832 char *kwnames[] = {
10833 (char *) "self", NULL
10834 };
10835
10836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10838 if (SWIG_arg_fail(1)) SWIG_fail;
10839 result = (byte) ((arg1)->blue);
10840
10841 {
10842 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10843 }
10844 return resultobj;
10845 fail:
10846 return NULL;
10847 }
10848
10849
10850 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10851 PyObject *obj;
10852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10853 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10854 Py_INCREF(obj);
10855 return Py_BuildValue((char *)"");
10856 }
10857 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj = NULL;
10859 double arg1 = (double) 0.0 ;
10860 double arg2 = (double) 0.0 ;
10861 double arg3 = (double) 0.0 ;
10862 wxImage_HSVValue *result;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 PyObject * obj2 = 0 ;
10866 char *kwnames[] = {
10867 (char *) "h",(char *) "s",(char *) "v", NULL
10868 };
10869
10870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10871 if (obj0) {
10872 {
10873 arg1 = static_cast<double >(SWIG_As_double(obj0));
10874 if (SWIG_arg_fail(1)) SWIG_fail;
10875 }
10876 }
10877 if (obj1) {
10878 {
10879 arg2 = static_cast<double >(SWIG_As_double(obj1));
10880 if (SWIG_arg_fail(2)) SWIG_fail;
10881 }
10882 }
10883 if (obj2) {
10884 {
10885 arg3 = static_cast<double >(SWIG_As_double(obj2));
10886 if (SWIG_arg_fail(3)) SWIG_fail;
10887 }
10888 }
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj = NULL;
10905 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10906 double arg2 ;
10907 PyObject * obj0 = 0 ;
10908 PyObject * obj1 = 0 ;
10909 char *kwnames[] = {
10910 (char *) "self",(char *) "hue", NULL
10911 };
10912
10913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10915 if (SWIG_arg_fail(1)) SWIG_fail;
10916 {
10917 arg2 = static_cast<double >(SWIG_As_double(obj1));
10918 if (SWIG_arg_fail(2)) SWIG_fail;
10919 }
10920 if (arg1) (arg1)->hue = arg2;
10921
10922 Py_INCREF(Py_None); resultobj = Py_None;
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj = NULL;
10931 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10932 double result;
10933 PyObject * obj0 = 0 ;
10934 char *kwnames[] = {
10935 (char *) "self", NULL
10936 };
10937
10938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10940 if (SWIG_arg_fail(1)) SWIG_fail;
10941 result = (double) ((arg1)->hue);
10942
10943 {
10944 resultobj = SWIG_From_double(static_cast<double >(result));
10945 }
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj = NULL;
10954 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10955 double arg2 ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char *kwnames[] = {
10959 (char *) "self",(char *) "saturation", NULL
10960 };
10961
10962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10964 if (SWIG_arg_fail(1)) SWIG_fail;
10965 {
10966 arg2 = static_cast<double >(SWIG_As_double(obj1));
10967 if (SWIG_arg_fail(2)) SWIG_fail;
10968 }
10969 if (arg1) (arg1)->saturation = arg2;
10970
10971 Py_INCREF(Py_None); resultobj = Py_None;
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj = NULL;
10980 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10981 double result;
10982 PyObject * obj0 = 0 ;
10983 char *kwnames[] = {
10984 (char *) "self", NULL
10985 };
10986
10987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10989 if (SWIG_arg_fail(1)) SWIG_fail;
10990 result = (double) ((arg1)->saturation);
10991
10992 {
10993 resultobj = SWIG_From_double(static_cast<double >(result));
10994 }
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj = NULL;
11003 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11004 double arg2 ;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 char *kwnames[] = {
11008 (char *) "self",(char *) "value", NULL
11009 };
11010
11011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(1)) SWIG_fail;
11014 {
11015 arg2 = static_cast<double >(SWIG_As_double(obj1));
11016 if (SWIG_arg_fail(2)) SWIG_fail;
11017 }
11018 if (arg1) (arg1)->value = arg2;
11019
11020 Py_INCREF(Py_None); resultobj = Py_None;
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj = NULL;
11029 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11030 double result;
11031 PyObject * obj0 = 0 ;
11032 char *kwnames[] = {
11033 (char *) "self", NULL
11034 };
11035
11036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11038 if (SWIG_arg_fail(1)) SWIG_fail;
11039 result = (double) ((arg1)->value);
11040
11041 {
11042 resultobj = SWIG_From_double(static_cast<double >(result));
11043 }
11044 return resultobj;
11045 fail:
11046 return NULL;
11047 }
11048
11049
11050 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11051 PyObject *obj;
11052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11053 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11054 Py_INCREF(obj);
11055 return Py_BuildValue((char *)"");
11056 }
11057 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj = NULL;
11059 wxString *arg1 = 0 ;
11060 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11061 int arg3 = (int) -1 ;
11062 wxImage *result;
11063 bool temp1 = false ;
11064 PyObject * obj0 = 0 ;
11065 PyObject * obj1 = 0 ;
11066 PyObject * obj2 = 0 ;
11067 char *kwnames[] = {
11068 (char *) "name",(char *) "type",(char *) "index", NULL
11069 };
11070
11071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11072 {
11073 arg1 = wxString_in_helper(obj0);
11074 if (arg1 == NULL) SWIG_fail;
11075 temp1 = true;
11076 }
11077 if (obj1) {
11078 {
11079 arg2 = static_cast<long >(SWIG_As_long(obj1));
11080 if (SWIG_arg_fail(2)) SWIG_fail;
11081 }
11082 }
11083 if (obj2) {
11084 {
11085 arg3 = static_cast<int >(SWIG_As_int(obj2));
11086 if (SWIG_arg_fail(3)) SWIG_fail;
11087 }
11088 }
11089 {
11090 PyThreadState* __tstate = wxPyBeginAllowThreads();
11091 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11092
11093 wxPyEndAllowThreads(__tstate);
11094 if (PyErr_Occurred()) SWIG_fail;
11095 }
11096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11097 {
11098 if (temp1)
11099 delete arg1;
11100 }
11101 return resultobj;
11102 fail:
11103 {
11104 if (temp1)
11105 delete arg1;
11106 }
11107 return NULL;
11108 }
11109
11110
11111 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj = NULL;
11113 wxImage *arg1 = (wxImage *) 0 ;
11114 PyObject * obj0 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 delete arg1;
11125
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 Py_INCREF(Py_None); resultobj = Py_None;
11130 return resultobj;
11131 fail:
11132 return NULL;
11133 }
11134
11135
11136 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11137 PyObject *resultobj = NULL;
11138 wxString *arg1 = 0 ;
11139 wxString *arg2 = 0 ;
11140 int arg3 = (int) -1 ;
11141 wxImage *result;
11142 bool temp1 = false ;
11143 bool temp2 = false ;
11144 PyObject * obj0 = 0 ;
11145 PyObject * obj1 = 0 ;
11146 PyObject * obj2 = 0 ;
11147 char *kwnames[] = {
11148 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11149 };
11150
11151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11152 {
11153 arg1 = wxString_in_helper(obj0);
11154 if (arg1 == NULL) SWIG_fail;
11155 temp1 = true;
11156 }
11157 {
11158 arg2 = wxString_in_helper(obj1);
11159 if (arg2 == NULL) SWIG_fail;
11160 temp2 = true;
11161 }
11162 if (obj2) {
11163 {
11164 arg3 = static_cast<int >(SWIG_As_int(obj2));
11165 if (SWIG_arg_fail(3)) SWIG_fail;
11166 }
11167 }
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11176 {
11177 if (temp1)
11178 delete arg1;
11179 }
11180 {
11181 if (temp2)
11182 delete arg2;
11183 }
11184 return resultobj;
11185 fail:
11186 {
11187 if (temp1)
11188 delete arg1;
11189 }
11190 {
11191 if (temp2)
11192 delete arg2;
11193 }
11194 return NULL;
11195 }
11196
11197
11198 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11199 PyObject *resultobj = NULL;
11200 wxInputStream *arg1 = 0 ;
11201 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11202 int arg3 = (int) -1 ;
11203 wxImage *result;
11204 wxPyInputStream *temp1 ;
11205 bool created1 ;
11206 PyObject * obj0 = 0 ;
11207 PyObject * obj1 = 0 ;
11208 PyObject * obj2 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "stream",(char *) "type",(char *) "index", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11214 {
11215 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11216 arg1 = temp1->m_wxis;
11217 created1 = false;
11218 } else {
11219 PyErr_Clear(); // clear the failure of the wxPyConvert above
11220 arg1 = wxPyCBInputStream_create(obj0, false);
11221 if (arg1 == NULL) {
11222 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11223 SWIG_fail;
11224 }
11225 created1 = true;
11226 }
11227 }
11228 if (obj1) {
11229 {
11230 arg2 = static_cast<long >(SWIG_As_long(obj1));
11231 if (SWIG_arg_fail(2)) SWIG_fail;
11232 }
11233 }
11234 if (obj2) {
11235 {
11236 arg3 = static_cast<int >(SWIG_As_int(obj2));
11237 if (SWIG_arg_fail(3)) SWIG_fail;
11238 }
11239 }
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11243
11244 wxPyEndAllowThreads(__tstate);
11245 if (PyErr_Occurred()) SWIG_fail;
11246 }
11247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11248 {
11249 if (created1) delete arg1;
11250 }
11251 return resultobj;
11252 fail:
11253 {
11254 if (created1) delete arg1;
11255 }
11256 return NULL;
11257 }
11258
11259
11260 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = NULL;
11262 wxInputStream *arg1 = 0 ;
11263 wxString *arg2 = 0 ;
11264 int arg3 = (int) -1 ;
11265 wxImage *result;
11266 wxPyInputStream *temp1 ;
11267 bool created1 ;
11268 bool temp2 = false ;
11269 PyObject * obj0 = 0 ;
11270 PyObject * obj1 = 0 ;
11271 PyObject * obj2 = 0 ;
11272 char *kwnames[] = {
11273 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11274 };
11275
11276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11277 {
11278 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11279 arg1 = temp1->m_wxis;
11280 created1 = false;
11281 } else {
11282 PyErr_Clear(); // clear the failure of the wxPyConvert above
11283 arg1 = wxPyCBInputStream_create(obj0, false);
11284 if (arg1 == NULL) {
11285 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11286 SWIG_fail;
11287 }
11288 created1 = true;
11289 }
11290 }
11291 {
11292 arg2 = wxString_in_helper(obj1);
11293 if (arg2 == NULL) SWIG_fail;
11294 temp2 = true;
11295 }
11296 if (obj2) {
11297 {
11298 arg3 = static_cast<int >(SWIG_As_int(obj2));
11299 if (SWIG_arg_fail(3)) SWIG_fail;
11300 }
11301 }
11302 {
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11305
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11310 {
11311 if (created1) delete arg1;
11312 }
11313 {
11314 if (temp2)
11315 delete arg2;
11316 }
11317 return resultobj;
11318 fail:
11319 {
11320 if (created1) delete arg1;
11321 }
11322 {
11323 if (temp2)
11324 delete arg2;
11325 }
11326 return NULL;
11327 }
11328
11329
11330 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj = NULL;
11332 int arg1 = (int) 0 ;
11333 int arg2 = (int) 0 ;
11334 bool arg3 = (bool) true ;
11335 wxImage *result;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 PyObject * obj2 = 0 ;
11339 char *kwnames[] = {
11340 (char *) "width",(char *) "height",(char *) "clear", NULL
11341 };
11342
11343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11344 if (obj0) {
11345 {
11346 arg1 = static_cast<int >(SWIG_As_int(obj0));
11347 if (SWIG_arg_fail(1)) SWIG_fail;
11348 }
11349 }
11350 if (obj1) {
11351 {
11352 arg2 = static_cast<int >(SWIG_As_int(obj1));
11353 if (SWIG_arg_fail(2)) SWIG_fail;
11354 }
11355 }
11356 if (obj2) {
11357 {
11358 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11359 if (SWIG_arg_fail(3)) SWIG_fail;
11360 }
11361 }
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11365
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11370 return resultobj;
11371 fail:
11372 return NULL;
11373 }
11374
11375
11376 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11377 PyObject *resultobj = NULL;
11378 wxBitmap *arg1 = 0 ;
11379 wxImage *result;
11380 PyObject * obj0 = 0 ;
11381 char *kwnames[] = {
11382 (char *) "bitmap", NULL
11383 };
11384
11385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11386 {
11387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11388 if (SWIG_arg_fail(1)) SWIG_fail;
11389 if (arg1 == NULL) {
11390 SWIG_null_ref("wxBitmap");
11391 }
11392 if (SWIG_arg_fail(1)) SWIG_fail;
11393 }
11394 {
11395 if (!wxPyCheckForApp()) SWIG_fail;
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11398
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj = NULL;
11411 int arg1 ;
11412 int arg2 ;
11413 buffer arg3 ;
11414 int arg4 ;
11415 wxImage *result;
11416 PyObject * obj0 = 0 ;
11417 PyObject * obj1 = 0 ;
11418 PyObject * obj2 = 0 ;
11419 char *kwnames[] = {
11420 (char *) "width",(char *) "height",(char *) "data", NULL
11421 };
11422
11423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11424 {
11425 arg1 = static_cast<int >(SWIG_As_int(obj0));
11426 if (SWIG_arg_fail(1)) SWIG_fail;
11427 }
11428 {
11429 arg2 = static_cast<int >(SWIG_As_int(obj1));
11430 if (SWIG_arg_fail(2)) SWIG_fail;
11431 }
11432 {
11433 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11434 }
11435 {
11436 PyThreadState* __tstate = wxPyBeginAllowThreads();
11437 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11438
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj = NULL;
11451 int arg1 ;
11452 int arg2 ;
11453 buffer arg3 ;
11454 int arg4 ;
11455 buffer arg5 ;
11456 int arg6 ;
11457 wxImage *result;
11458 PyObject * obj0 = 0 ;
11459 PyObject * obj1 = 0 ;
11460 PyObject * obj2 = 0 ;
11461 PyObject * obj3 = 0 ;
11462 char *kwnames[] = {
11463 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11464 };
11465
11466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11467 {
11468 arg1 = static_cast<int >(SWIG_As_int(obj0));
11469 if (SWIG_arg_fail(1)) SWIG_fail;
11470 }
11471 {
11472 arg2 = static_cast<int >(SWIG_As_int(obj1));
11473 if (SWIG_arg_fail(2)) SWIG_fail;
11474 }
11475 {
11476 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11477 }
11478 {
11479 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11480 }
11481 {
11482 PyThreadState* __tstate = wxPyBeginAllowThreads();
11483 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11484
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11489 return resultobj;
11490 fail:
11491 return NULL;
11492 }
11493
11494
11495 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11496 PyObject *resultobj = NULL;
11497 wxImage *arg1 = (wxImage *) 0 ;
11498 int arg2 ;
11499 int arg3 ;
11500 bool arg4 = (bool) true ;
11501 PyObject * obj0 = 0 ;
11502 PyObject * obj1 = 0 ;
11503 PyObject * obj2 = 0 ;
11504 PyObject * obj3 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11511 if (SWIG_arg_fail(1)) SWIG_fail;
11512 {
11513 arg2 = static_cast<int >(SWIG_As_int(obj1));
11514 if (SWIG_arg_fail(2)) SWIG_fail;
11515 }
11516 {
11517 arg3 = static_cast<int >(SWIG_As_int(obj2));
11518 if (SWIG_arg_fail(3)) SWIG_fail;
11519 }
11520 if (obj3) {
11521 {
11522 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11523 if (SWIG_arg_fail(4)) SWIG_fail;
11524 }
11525 }
11526 {
11527 PyThreadState* __tstate = wxPyBeginAllowThreads();
11528 (arg1)->Create(arg2,arg3,arg4);
11529
11530 wxPyEndAllowThreads(__tstate);
11531 if (PyErr_Occurred()) SWIG_fail;
11532 }
11533 Py_INCREF(Py_None); resultobj = Py_None;
11534 return resultobj;
11535 fail:
11536 return NULL;
11537 }
11538
11539
11540 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11541 PyObject *resultobj = NULL;
11542 wxImage *arg1 = (wxImage *) 0 ;
11543 PyObject * obj0 = 0 ;
11544 char *kwnames[] = {
11545 (char *) "self", NULL
11546 };
11547
11548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11550 if (SWIG_arg_fail(1)) SWIG_fail;
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 (arg1)->Destroy();
11554
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 Py_INCREF(Py_None); resultobj = Py_None;
11559 return resultobj;
11560 fail:
11561 return NULL;
11562 }
11563
11564
11565 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = NULL;
11567 wxImage *arg1 = (wxImage *) 0 ;
11568 int arg2 ;
11569 int arg3 ;
11570 SwigValueWrapper<wxImage > result;
11571 PyObject * obj0 = 0 ;
11572 PyObject * obj1 = 0 ;
11573 PyObject * obj2 = 0 ;
11574 char *kwnames[] = {
11575 (char *) "self",(char *) "width",(char *) "height", NULL
11576 };
11577
11578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11580 if (SWIG_arg_fail(1)) SWIG_fail;
11581 {
11582 arg2 = static_cast<int >(SWIG_As_int(obj1));
11583 if (SWIG_arg_fail(2)) SWIG_fail;
11584 }
11585 {
11586 arg3 = static_cast<int >(SWIG_As_int(obj2));
11587 if (SWIG_arg_fail(3)) SWIG_fail;
11588 }
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (arg1)->Scale(arg2,arg3);
11592
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 {
11597 wxImage * resultptr;
11598 resultptr = new wxImage(static_cast<wxImage & >(result));
11599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11600 }
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11608 PyObject *resultobj = NULL;
11609 wxImage *arg1 = (wxImage *) 0 ;
11610 int arg2 ;
11611 int arg3 ;
11612 SwigValueWrapper<wxImage > result;
11613 PyObject * obj0 = 0 ;
11614 PyObject * obj1 = 0 ;
11615 PyObject * obj2 = 0 ;
11616 char *kwnames[] = {
11617 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11618 };
11619
11620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11622 if (SWIG_arg_fail(1)) SWIG_fail;
11623 {
11624 arg2 = static_cast<int >(SWIG_As_int(obj1));
11625 if (SWIG_arg_fail(2)) SWIG_fail;
11626 }
11627 {
11628 arg3 = static_cast<int >(SWIG_As_int(obj2));
11629 if (SWIG_arg_fail(3)) SWIG_fail;
11630 }
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11634
11635 wxPyEndAllowThreads(__tstate);
11636 if (PyErr_Occurred()) SWIG_fail;
11637 }
11638 {
11639 wxImage * resultptr;
11640 resultptr = new wxImage(static_cast<wxImage & >(result));
11641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11642 }
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11650 PyObject *resultobj = NULL;
11651 wxImage *arg1 = (wxImage *) 0 ;
11652 int arg2 ;
11653 int arg3 ;
11654 wxImage *result;
11655 PyObject * obj0 = 0 ;
11656 PyObject * obj1 = 0 ;
11657 PyObject * obj2 = 0 ;
11658 char *kwnames[] = {
11659 (char *) "self",(char *) "width",(char *) "height", NULL
11660 };
11661
11662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11664 if (SWIG_arg_fail(1)) SWIG_fail;
11665 {
11666 arg2 = static_cast<int >(SWIG_As_int(obj1));
11667 if (SWIG_arg_fail(2)) SWIG_fail;
11668 }
11669 {
11670 arg3 = static_cast<int >(SWIG_As_int(obj2));
11671 if (SWIG_arg_fail(3)) SWIG_fail;
11672 }
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 {
11676 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11677 result = (wxImage *) &_result_ref;
11678 }
11679
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11691 PyObject *resultobj = NULL;
11692 wxImage *arg1 = (wxImage *) 0 ;
11693 wxSize *arg2 = 0 ;
11694 wxPoint *arg3 = 0 ;
11695 int arg4 = (int) -1 ;
11696 int arg5 = (int) -1 ;
11697 int arg6 = (int) -1 ;
11698 wxImage *result;
11699 wxSize temp2 ;
11700 wxPoint temp3 ;
11701 PyObject * obj0 = 0 ;
11702 PyObject * obj1 = 0 ;
11703 PyObject * obj2 = 0 ;
11704 PyObject * obj3 = 0 ;
11705 PyObject * obj4 = 0 ;
11706 PyObject * obj5 = 0 ;
11707 char *kwnames[] = {
11708 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11709 };
11710
11711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11713 if (SWIG_arg_fail(1)) SWIG_fail;
11714 {
11715 arg2 = &temp2;
11716 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11717 }
11718 {
11719 arg3 = &temp3;
11720 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11721 }
11722 if (obj3) {
11723 {
11724 arg4 = static_cast<int >(SWIG_As_int(obj3));
11725 if (SWIG_arg_fail(4)) SWIG_fail;
11726 }
11727 }
11728 if (obj4) {
11729 {
11730 arg5 = static_cast<int >(SWIG_As_int(obj4));
11731 if (SWIG_arg_fail(5)) SWIG_fail;
11732 }
11733 }
11734 if (obj5) {
11735 {
11736 arg6 = static_cast<int >(SWIG_As_int(obj5));
11737 if (SWIG_arg_fail(6)) SWIG_fail;
11738 }
11739 }
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 {
11743 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11744 result = (wxImage *) &_result_ref;
11745 }
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11751 return resultobj;
11752 fail:
11753 return NULL;
11754 }
11755
11756
11757 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11758 PyObject *resultobj = NULL;
11759 wxImage *arg1 = (wxImage *) 0 ;
11760 int arg2 ;
11761 int arg3 ;
11762 byte arg4 ;
11763 byte arg5 ;
11764 byte arg6 ;
11765 PyObject * obj0 = 0 ;
11766 PyObject * obj1 = 0 ;
11767 PyObject * obj2 = 0 ;
11768 PyObject * obj3 = 0 ;
11769 PyObject * obj4 = 0 ;
11770 PyObject * obj5 = 0 ;
11771 char *kwnames[] = {
11772 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11773 };
11774
11775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11777 if (SWIG_arg_fail(1)) SWIG_fail;
11778 {
11779 arg2 = static_cast<int >(SWIG_As_int(obj1));
11780 if (SWIG_arg_fail(2)) SWIG_fail;
11781 }
11782 {
11783 arg3 = static_cast<int >(SWIG_As_int(obj2));
11784 if (SWIG_arg_fail(3)) SWIG_fail;
11785 }
11786 {
11787 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11788 if (SWIG_arg_fail(4)) SWIG_fail;
11789 }
11790 {
11791 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11792 if (SWIG_arg_fail(5)) SWIG_fail;
11793 }
11794 {
11795 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11796 if (SWIG_arg_fail(6)) SWIG_fail;
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 Py_INCREF(Py_None); resultobj = Py_None;
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj = NULL;
11814 wxImage *arg1 = (wxImage *) 0 ;
11815 wxRect *arg2 = 0 ;
11816 byte arg3 ;
11817 byte arg4 ;
11818 byte arg5 ;
11819 wxRect temp2 ;
11820 PyObject * obj0 = 0 ;
11821 PyObject * obj1 = 0 ;
11822 PyObject * obj2 = 0 ;
11823 PyObject * obj3 = 0 ;
11824 PyObject * obj4 = 0 ;
11825 char *kwnames[] = {
11826 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11827 };
11828
11829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11831 if (SWIG_arg_fail(1)) SWIG_fail;
11832 {
11833 arg2 = &temp2;
11834 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11835 }
11836 {
11837 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11838 if (SWIG_arg_fail(3)) SWIG_fail;
11839 }
11840 {
11841 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11842 if (SWIG_arg_fail(4)) SWIG_fail;
11843 }
11844 {
11845 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11846 if (SWIG_arg_fail(5)) SWIG_fail;
11847 }
11848 {
11849 PyThreadState* __tstate = wxPyBeginAllowThreads();
11850 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11851
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 Py_INCREF(Py_None); resultobj = Py_None;
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11863 PyObject *resultobj = NULL;
11864 wxImage *arg1 = (wxImage *) 0 ;
11865 int arg2 ;
11866 int arg3 ;
11867 byte result;
11868 PyObject * obj0 = 0 ;
11869 PyObject * obj1 = 0 ;
11870 PyObject * obj2 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self",(char *) "x",(char *) "y", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 arg2 = static_cast<int >(SWIG_As_int(obj1));
11880 if (SWIG_arg_fail(2)) SWIG_fail;
11881 }
11882 {
11883 arg3 = static_cast<int >(SWIG_As_int(obj2));
11884 if (SWIG_arg_fail(3)) SWIG_fail;
11885 }
11886 {
11887 PyThreadState* __tstate = wxPyBeginAllowThreads();
11888 result = (byte)(arg1)->GetRed(arg2,arg3);
11889
11890 wxPyEndAllowThreads(__tstate);
11891 if (PyErr_Occurred()) SWIG_fail;
11892 }
11893 {
11894 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11895 }
11896 return resultobj;
11897 fail:
11898 return NULL;
11899 }
11900
11901
11902 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11903 PyObject *resultobj = NULL;
11904 wxImage *arg1 = (wxImage *) 0 ;
11905 int arg2 ;
11906 int arg3 ;
11907 byte result;
11908 PyObject * obj0 = 0 ;
11909 PyObject * obj1 = 0 ;
11910 PyObject * obj2 = 0 ;
11911 char *kwnames[] = {
11912 (char *) "self",(char *) "x",(char *) "y", NULL
11913 };
11914
11915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11917 if (SWIG_arg_fail(1)) SWIG_fail;
11918 {
11919 arg2 = static_cast<int >(SWIG_As_int(obj1));
11920 if (SWIG_arg_fail(2)) SWIG_fail;
11921 }
11922 {
11923 arg3 = static_cast<int >(SWIG_As_int(obj2));
11924 if (SWIG_arg_fail(3)) SWIG_fail;
11925 }
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 result = (byte)(arg1)->GetGreen(arg2,arg3);
11929
11930 wxPyEndAllowThreads(__tstate);
11931 if (PyErr_Occurred()) SWIG_fail;
11932 }
11933 {
11934 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11935 }
11936 return resultobj;
11937 fail:
11938 return NULL;
11939 }
11940
11941
11942 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11943 PyObject *resultobj = NULL;
11944 wxImage *arg1 = (wxImage *) 0 ;
11945 int arg2 ;
11946 int arg3 ;
11947 byte result;
11948 PyObject * obj0 = 0 ;
11949 PyObject * obj1 = 0 ;
11950 PyObject * obj2 = 0 ;
11951 char *kwnames[] = {
11952 (char *) "self",(char *) "x",(char *) "y", NULL
11953 };
11954
11955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11957 if (SWIG_arg_fail(1)) SWIG_fail;
11958 {
11959 arg2 = static_cast<int >(SWIG_As_int(obj1));
11960 if (SWIG_arg_fail(2)) SWIG_fail;
11961 }
11962 {
11963 arg3 = static_cast<int >(SWIG_As_int(obj2));
11964 if (SWIG_arg_fail(3)) SWIG_fail;
11965 }
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (byte)(arg1)->GetBlue(arg2,arg3);
11969
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 {
11974 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11975 }
11976 return resultobj;
11977 fail:
11978 return NULL;
11979 }
11980
11981
11982 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11983 PyObject *resultobj = NULL;
11984 wxImage *arg1 = (wxImage *) 0 ;
11985 int arg2 ;
11986 int arg3 ;
11987 byte arg4 ;
11988 PyObject * obj0 = 0 ;
11989 PyObject * obj1 = 0 ;
11990 PyObject * obj2 = 0 ;
11991 PyObject * obj3 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 arg2 = static_cast<int >(SWIG_As_int(obj1));
12001 if (SWIG_arg_fail(2)) SWIG_fail;
12002 }
12003 {
12004 arg3 = static_cast<int >(SWIG_As_int(obj2));
12005 if (SWIG_arg_fail(3)) SWIG_fail;
12006 }
12007 {
12008 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12009 if (SWIG_arg_fail(4)) SWIG_fail;
12010 }
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 (arg1)->SetAlpha(arg2,arg3,arg4);
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 Py_INCREF(Py_None); resultobj = Py_None;
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj = NULL;
12027 wxImage *arg1 = (wxImage *) 0 ;
12028 int arg2 ;
12029 int arg3 ;
12030 byte result;
12031 PyObject * obj0 = 0 ;
12032 PyObject * obj1 = 0 ;
12033 PyObject * obj2 = 0 ;
12034 char *kwnames[] = {
12035 (char *) "self",(char *) "x",(char *) "y", NULL
12036 };
12037
12038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12040 if (SWIG_arg_fail(1)) SWIG_fail;
12041 {
12042 arg2 = static_cast<int >(SWIG_As_int(obj1));
12043 if (SWIG_arg_fail(2)) SWIG_fail;
12044 }
12045 {
12046 arg3 = static_cast<int >(SWIG_As_int(obj2));
12047 if (SWIG_arg_fail(3)) SWIG_fail;
12048 }
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12052
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 {
12057 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12058 }
12059 return resultobj;
12060 fail:
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj = NULL;
12067 wxImage *arg1 = (wxImage *) 0 ;
12068 bool result;
12069 PyObject * obj0 = 0 ;
12070 char *kwnames[] = {
12071 (char *) "self", NULL
12072 };
12073
12074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12076 if (SWIG_arg_fail(1)) SWIG_fail;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (bool)(arg1)->HasAlpha();
12080
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 {
12085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12086 }
12087 return resultobj;
12088 fail:
12089 return NULL;
12090 }
12091
12092
12093 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12094 PyObject *resultobj = NULL;
12095 wxImage *arg1 = (wxImage *) 0 ;
12096 PyObject * obj0 = 0 ;
12097 char *kwnames[] = {
12098 (char *) "self", NULL
12099 };
12100
12101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12103 if (SWIG_arg_fail(1)) SWIG_fail;
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 (arg1)->InitAlpha();
12107
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 Py_INCREF(Py_None); resultobj = Py_None;
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = NULL;
12120 wxImage *arg1 = (wxImage *) 0 ;
12121 int arg2 ;
12122 int arg3 ;
12123 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12124 bool result;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12127 PyObject * obj2 = 0 ;
12128 PyObject * obj3 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 arg2 = static_cast<int >(SWIG_As_int(obj1));
12138 if (SWIG_arg_fail(2)) SWIG_fail;
12139 }
12140 {
12141 arg3 = static_cast<int >(SWIG_As_int(obj2));
12142 if (SWIG_arg_fail(3)) SWIG_fail;
12143 }
12144 if (obj3) {
12145 {
12146 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12147 if (SWIG_arg_fail(4)) SWIG_fail;
12148 }
12149 }
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12153
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 {
12158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12159 }
12160 return resultobj;
12161 fail:
12162 return NULL;
12163 }
12164
12165
12166 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12167 PyObject *resultobj = NULL;
12168 wxImage *arg1 = (wxImage *) 0 ;
12169 byte *arg2 = (byte *) 0 ;
12170 byte *arg3 = (byte *) 0 ;
12171 byte *arg4 = (byte *) 0 ;
12172 byte arg5 = (byte) 0 ;
12173 byte arg6 = (byte) 0 ;
12174 byte arg7 = (byte) 0 ;
12175 bool result;
12176 byte temp2 ;
12177 int res2 = 0 ;
12178 byte temp3 ;
12179 int res3 = 0 ;
12180 byte temp4 ;
12181 int res4 = 0 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 PyObject * obj2 = 0 ;
12185 PyObject * obj3 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12188 };
12189
12190 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12191 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12192 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12195 if (SWIG_arg_fail(1)) SWIG_fail;
12196 if (obj1) {
12197 {
12198 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12199 if (SWIG_arg_fail(5)) SWIG_fail;
12200 }
12201 }
12202 if (obj2) {
12203 {
12204 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12205 if (SWIG_arg_fail(6)) SWIG_fail;
12206 }
12207 }
12208 if (obj3) {
12209 {
12210 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12211 if (SWIG_arg_fail(7)) SWIG_fail;
12212 }
12213 }
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12217
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12223 }
12224 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12225 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12226 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12227 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12228 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12229 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj = NULL;
12238 wxImage *arg1 = (wxImage *) 0 ;
12239 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12240 bool result;
12241 PyObject * obj0 = 0 ;
12242 PyObject * obj1 = 0 ;
12243 char *kwnames[] = {
12244 (char *) "self",(char *) "threshold", NULL
12245 };
12246
12247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12249 if (SWIG_arg_fail(1)) SWIG_fail;
12250 if (obj1) {
12251 {
12252 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12253 if (SWIG_arg_fail(2)) SWIG_fail;
12254 }
12255 }
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12259
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 {
12264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12265 }
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj = NULL;
12274 wxImage *arg1 = (wxImage *) 0 ;
12275 byte arg2 ;
12276 byte arg3 ;
12277 byte arg4 ;
12278 bool result;
12279 PyObject * obj0 = 0 ;
12280 PyObject * obj1 = 0 ;
12281 PyObject * obj2 = 0 ;
12282 PyObject * obj3 = 0 ;
12283 char *kwnames[] = {
12284 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12285 };
12286
12287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12289 if (SWIG_arg_fail(1)) SWIG_fail;
12290 {
12291 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12292 if (SWIG_arg_fail(2)) SWIG_fail;
12293 }
12294 {
12295 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12296 if (SWIG_arg_fail(3)) SWIG_fail;
12297 }
12298 {
12299 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12300 if (SWIG_arg_fail(4)) SWIG_fail;
12301 }
12302 {
12303 PyThreadState* __tstate = wxPyBeginAllowThreads();
12304 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12305
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12311 }
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12319 PyObject *resultobj = NULL;
12320 wxImage *arg1 = (wxImage *) 0 ;
12321 wxImage *arg2 = 0 ;
12322 byte arg3 ;
12323 byte arg4 ;
12324 byte arg5 ;
12325 bool result;
12326 PyObject * obj0 = 0 ;
12327 PyObject * obj1 = 0 ;
12328 PyObject * obj2 = 0 ;
12329 PyObject * obj3 = 0 ;
12330 PyObject * obj4 = 0 ;
12331 char *kwnames[] = {
12332 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12333 };
12334
12335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12337 if (SWIG_arg_fail(1)) SWIG_fail;
12338 {
12339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(2)) SWIG_fail;
12341 if (arg2 == NULL) {
12342 SWIG_null_ref("wxImage");
12343 }
12344 if (SWIG_arg_fail(2)) SWIG_fail;
12345 }
12346 {
12347 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12348 if (SWIG_arg_fail(3)) SWIG_fail;
12349 }
12350 {
12351 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12352 if (SWIG_arg_fail(4)) SWIG_fail;
12353 }
12354 {
12355 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12356 if (SWIG_arg_fail(5)) SWIG_fail;
12357 }
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12361
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 {
12366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj = NULL;
12376 wxString *arg1 = 0 ;
12377 bool result;
12378 bool temp1 = false ;
12379 PyObject * obj0 = 0 ;
12380 char *kwnames[] = {
12381 (char *) "filename", NULL
12382 };
12383
12384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12385 {
12386 arg1 = wxString_in_helper(obj0);
12387 if (arg1 == NULL) SWIG_fail;
12388 temp1 = true;
12389 }
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12393
12394 wxPyEndAllowThreads(__tstate);
12395 if (PyErr_Occurred()) SWIG_fail;
12396 }
12397 {
12398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12399 }
12400 {
12401 if (temp1)
12402 delete arg1;
12403 }
12404 return resultobj;
12405 fail:
12406 {
12407 if (temp1)
12408 delete arg1;
12409 }
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = NULL;
12416 wxString *arg1 = 0 ;
12417 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12418 int result;
12419 bool temp1 = false ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 char *kwnames[] = {
12423 (char *) "filename",(char *) "type", NULL
12424 };
12425
12426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12427 {
12428 arg1 = wxString_in_helper(obj0);
12429 if (arg1 == NULL) SWIG_fail;
12430 temp1 = true;
12431 }
12432 if (obj1) {
12433 {
12434 arg2 = static_cast<long >(SWIG_As_long(obj1));
12435 if (SWIG_arg_fail(2)) SWIG_fail;
12436 }
12437 }
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12441
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 resultobj = SWIG_From_int(static_cast<int >(result));
12447 }
12448 {
12449 if (temp1)
12450 delete arg1;
12451 }
12452 return resultobj;
12453 fail:
12454 {
12455 if (temp1)
12456 delete arg1;
12457 }
12458 return NULL;
12459 }
12460
12461
12462 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12463 PyObject *resultobj = NULL;
12464 wxImage *arg1 = (wxImage *) 0 ;
12465 wxString *arg2 = 0 ;
12466 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12467 int arg4 = (int) -1 ;
12468 bool result;
12469 bool temp2 = false ;
12470 PyObject * obj0 = 0 ;
12471 PyObject * obj1 = 0 ;
12472 PyObject * obj2 = 0 ;
12473 PyObject * obj3 = 0 ;
12474 char *kwnames[] = {
12475 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12476 };
12477
12478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12480 if (SWIG_arg_fail(1)) SWIG_fail;
12481 {
12482 arg2 = wxString_in_helper(obj1);
12483 if (arg2 == NULL) SWIG_fail;
12484 temp2 = true;
12485 }
12486 if (obj2) {
12487 {
12488 arg3 = static_cast<long >(SWIG_As_long(obj2));
12489 if (SWIG_arg_fail(3)) SWIG_fail;
12490 }
12491 }
12492 if (obj3) {
12493 {
12494 arg4 = static_cast<int >(SWIG_As_int(obj3));
12495 if (SWIG_arg_fail(4)) SWIG_fail;
12496 }
12497 }
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12501
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 {
12506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12507 }
12508 {
12509 if (temp2)
12510 delete arg2;
12511 }
12512 return resultobj;
12513 fail:
12514 {
12515 if (temp2)
12516 delete arg2;
12517 }
12518 return NULL;
12519 }
12520
12521
12522 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = NULL;
12524 wxImage *arg1 = (wxImage *) 0 ;
12525 wxString *arg2 = 0 ;
12526 wxString *arg3 = 0 ;
12527 int arg4 = (int) -1 ;
12528 bool result;
12529 bool temp2 = false ;
12530 bool temp3 = false ;
12531 PyObject * obj0 = 0 ;
12532 PyObject * obj1 = 0 ;
12533 PyObject * obj2 = 0 ;
12534 PyObject * obj3 = 0 ;
12535 char *kwnames[] = {
12536 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12537 };
12538
12539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12541 if (SWIG_arg_fail(1)) SWIG_fail;
12542 {
12543 arg2 = wxString_in_helper(obj1);
12544 if (arg2 == NULL) SWIG_fail;
12545 temp2 = true;
12546 }
12547 {
12548 arg3 = wxString_in_helper(obj2);
12549 if (arg3 == NULL) SWIG_fail;
12550 temp3 = true;
12551 }
12552 if (obj3) {
12553 {
12554 arg4 = static_cast<int >(SWIG_As_int(obj3));
12555 if (SWIG_arg_fail(4)) SWIG_fail;
12556 }
12557 }
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12561
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 {
12566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12567 }
12568 {
12569 if (temp2)
12570 delete arg2;
12571 }
12572 {
12573 if (temp3)
12574 delete arg3;
12575 }
12576 return resultobj;
12577 fail:
12578 {
12579 if (temp2)
12580 delete arg2;
12581 }
12582 {
12583 if (temp3)
12584 delete arg3;
12585 }
12586 return NULL;
12587 }
12588
12589
12590 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj = NULL;
12592 wxImage *arg1 = (wxImage *) 0 ;
12593 wxString *arg2 = 0 ;
12594 int arg3 ;
12595 bool result;
12596 bool temp2 = false ;
12597 PyObject * obj0 = 0 ;
12598 PyObject * obj1 = 0 ;
12599 PyObject * obj2 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self",(char *) "name",(char *) "type", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 arg2 = wxString_in_helper(obj1);
12609 if (arg2 == NULL) SWIG_fail;
12610 temp2 = true;
12611 }
12612 {
12613 arg3 = static_cast<int >(SWIG_As_int(obj2));
12614 if (SWIG_arg_fail(3)) SWIG_fail;
12615 }
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12619
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 {
12624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12625 }
12626 {
12627 if (temp2)
12628 delete arg2;
12629 }
12630 return resultobj;
12631 fail:
12632 {
12633 if (temp2)
12634 delete arg2;
12635 }
12636 return NULL;
12637 }
12638
12639
12640 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12641 PyObject *resultobj = NULL;
12642 wxImage *arg1 = (wxImage *) 0 ;
12643 wxString *arg2 = 0 ;
12644 wxString *arg3 = 0 ;
12645 bool result;
12646 bool temp2 = false ;
12647 bool temp3 = false ;
12648 PyObject * obj0 = 0 ;
12649 PyObject * obj1 = 0 ;
12650 PyObject * obj2 = 0 ;
12651 char *kwnames[] = {
12652 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12653 };
12654
12655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12657 if (SWIG_arg_fail(1)) SWIG_fail;
12658 {
12659 arg2 = wxString_in_helper(obj1);
12660 if (arg2 == NULL) SWIG_fail;
12661 temp2 = true;
12662 }
12663 {
12664 arg3 = wxString_in_helper(obj2);
12665 if (arg3 == NULL) SWIG_fail;
12666 temp3 = true;
12667 }
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12671
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 {
12676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12677 }
12678 {
12679 if (temp2)
12680 delete arg2;
12681 }
12682 {
12683 if (temp3)
12684 delete arg3;
12685 }
12686 return resultobj;
12687 fail:
12688 {
12689 if (temp2)
12690 delete arg2;
12691 }
12692 {
12693 if (temp3)
12694 delete arg3;
12695 }
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj = NULL;
12702 wxInputStream *arg1 = 0 ;
12703 bool result;
12704 wxPyInputStream *temp1 ;
12705 bool created1 ;
12706 PyObject * obj0 = 0 ;
12707 char *kwnames[] = {
12708 (char *) "stream", NULL
12709 };
12710
12711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12712 {
12713 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12714 arg1 = temp1->m_wxis;
12715 created1 = false;
12716 } else {
12717 PyErr_Clear(); // clear the failure of the wxPyConvert above
12718 arg1 = wxPyCBInputStream_create(obj0, false);
12719 if (arg1 == NULL) {
12720 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12721 SWIG_fail;
12722 }
12723 created1 = true;
12724 }
12725 }
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 result = (bool)wxImage::CanRead(*arg1);
12729
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 {
12734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12735 }
12736 {
12737 if (created1) delete arg1;
12738 }
12739 return resultobj;
12740 fail:
12741 {
12742 if (created1) delete arg1;
12743 }
12744 return NULL;
12745 }
12746
12747
12748 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12749 PyObject *resultobj = NULL;
12750 wxImage *arg1 = (wxImage *) 0 ;
12751 wxInputStream *arg2 = 0 ;
12752 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12753 int arg4 = (int) -1 ;
12754 bool result;
12755 wxPyInputStream *temp2 ;
12756 bool created2 ;
12757 PyObject * obj0 = 0 ;
12758 PyObject * obj1 = 0 ;
12759 PyObject * obj2 = 0 ;
12760 PyObject * obj3 = 0 ;
12761 char *kwnames[] = {
12762 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12763 };
12764
12765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(1)) SWIG_fail;
12768 {
12769 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12770 arg2 = temp2->m_wxis;
12771 created2 = false;
12772 } else {
12773 PyErr_Clear(); // clear the failure of the wxPyConvert above
12774 arg2 = wxPyCBInputStream_create(obj1, false);
12775 if (arg2 == NULL) {
12776 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12777 SWIG_fail;
12778 }
12779 created2 = true;
12780 }
12781 }
12782 if (obj2) {
12783 {
12784 arg3 = static_cast<long >(SWIG_As_long(obj2));
12785 if (SWIG_arg_fail(3)) SWIG_fail;
12786 }
12787 }
12788 if (obj3) {
12789 {
12790 arg4 = static_cast<int >(SWIG_As_int(obj3));
12791 if (SWIG_arg_fail(4)) SWIG_fail;
12792 }
12793 }
12794 {
12795 PyThreadState* __tstate = wxPyBeginAllowThreads();
12796 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12797
12798 wxPyEndAllowThreads(__tstate);
12799 if (PyErr_Occurred()) SWIG_fail;
12800 }
12801 {
12802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12803 }
12804 {
12805 if (created2) delete arg2;
12806 }
12807 return resultobj;
12808 fail:
12809 {
12810 if (created2) delete arg2;
12811 }
12812 return NULL;
12813 }
12814
12815
12816 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12817 PyObject *resultobj = NULL;
12818 wxImage *arg1 = (wxImage *) 0 ;
12819 wxInputStream *arg2 = 0 ;
12820 wxString *arg3 = 0 ;
12821 int arg4 = (int) -1 ;
12822 bool result;
12823 wxPyInputStream *temp2 ;
12824 bool created2 ;
12825 bool temp3 = false ;
12826 PyObject * obj0 = 0 ;
12827 PyObject * obj1 = 0 ;
12828 PyObject * obj2 = 0 ;
12829 PyObject * obj3 = 0 ;
12830 char *kwnames[] = {
12831 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12832 };
12833
12834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12836 if (SWIG_arg_fail(1)) SWIG_fail;
12837 {
12838 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12839 arg2 = temp2->m_wxis;
12840 created2 = false;
12841 } else {
12842 PyErr_Clear(); // clear the failure of the wxPyConvert above
12843 arg2 = wxPyCBInputStream_create(obj1, false);
12844 if (arg2 == NULL) {
12845 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12846 SWIG_fail;
12847 }
12848 created2 = true;
12849 }
12850 }
12851 {
12852 arg3 = wxString_in_helper(obj2);
12853 if (arg3 == NULL) SWIG_fail;
12854 temp3 = true;
12855 }
12856 if (obj3) {
12857 {
12858 arg4 = static_cast<int >(SWIG_As_int(obj3));
12859 if (SWIG_arg_fail(4)) SWIG_fail;
12860 }
12861 }
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12865
12866 wxPyEndAllowThreads(__tstate);
12867 if (PyErr_Occurred()) SWIG_fail;
12868 }
12869 {
12870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12871 }
12872 {
12873 if (created2) delete arg2;
12874 }
12875 {
12876 if (temp3)
12877 delete arg3;
12878 }
12879 return resultobj;
12880 fail:
12881 {
12882 if (created2) delete arg2;
12883 }
12884 {
12885 if (temp3)
12886 delete arg3;
12887 }
12888 return NULL;
12889 }
12890
12891
12892 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12893 PyObject *resultobj = NULL;
12894 wxImage *arg1 = (wxImage *) 0 ;
12895 bool result;
12896 PyObject * obj0 = 0 ;
12897 char *kwnames[] = {
12898 (char *) "self", NULL
12899 };
12900
12901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12903 if (SWIG_arg_fail(1)) SWIG_fail;
12904 {
12905 PyThreadState* __tstate = wxPyBeginAllowThreads();
12906 result = (bool)(arg1)->Ok();
12907
12908 wxPyEndAllowThreads(__tstate);
12909 if (PyErr_Occurred()) SWIG_fail;
12910 }
12911 {
12912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12913 }
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj = NULL;
12922 wxImage *arg1 = (wxImage *) 0 ;
12923 int result;
12924 PyObject * obj0 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 result = (int)(arg1)->GetWidth();
12935
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 {
12940 resultobj = SWIG_From_int(static_cast<int >(result));
12941 }
12942 return resultobj;
12943 fail:
12944 return NULL;
12945 }
12946
12947
12948 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = NULL;
12950 wxImage *arg1 = (wxImage *) 0 ;
12951 int result;
12952 PyObject * obj0 = 0 ;
12953 char *kwnames[] = {
12954 (char *) "self", NULL
12955 };
12956
12957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12959 if (SWIG_arg_fail(1)) SWIG_fail;
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 result = (int)(arg1)->GetHeight();
12963
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 {
12968 resultobj = SWIG_From_int(static_cast<int >(result));
12969 }
12970 return resultobj;
12971 fail:
12972 return NULL;
12973 }
12974
12975
12976 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12977 PyObject *resultobj = NULL;
12978 wxImage *arg1 = (wxImage *) 0 ;
12979 wxSize result;
12980 PyObject * obj0 = 0 ;
12981 char *kwnames[] = {
12982 (char *) "self", NULL
12983 };
12984
12985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12987 if (SWIG_arg_fail(1)) SWIG_fail;
12988 {
12989 PyThreadState* __tstate = wxPyBeginAllowThreads();
12990 result = wxImage_GetSize(arg1);
12991
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 {
12996 wxSize * resultptr;
12997 resultptr = new wxSize(static_cast<wxSize & >(result));
12998 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = NULL;
13008 wxImage *arg1 = (wxImage *) 0 ;
13009 wxRect *arg2 = 0 ;
13010 SwigValueWrapper<wxImage > result;
13011 wxRect temp2 ;
13012 PyObject * obj0 = 0 ;
13013 PyObject * obj1 = 0 ;
13014 char *kwnames[] = {
13015 (char *) "self",(char *) "rect", NULL
13016 };
13017
13018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13020 if (SWIG_arg_fail(1)) SWIG_fail;
13021 {
13022 arg2 = &temp2;
13023 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13028
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 {
13033 wxImage * resultptr;
13034 resultptr = new wxImage(static_cast<wxImage & >(result));
13035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13036 }
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj = NULL;
13045 wxImage *arg1 = (wxImage *) 0 ;
13046 wxSize *arg2 = 0 ;
13047 wxPoint *arg3 = 0 ;
13048 int arg4 = (int) -1 ;
13049 int arg5 = (int) -1 ;
13050 int arg6 = (int) -1 ;
13051 SwigValueWrapper<wxImage > result;
13052 wxSize temp2 ;
13053 wxPoint temp3 ;
13054 PyObject * obj0 = 0 ;
13055 PyObject * obj1 = 0 ;
13056 PyObject * obj2 = 0 ;
13057 PyObject * obj3 = 0 ;
13058 PyObject * obj4 = 0 ;
13059 PyObject * obj5 = 0 ;
13060 char *kwnames[] = {
13061 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13062 };
13063
13064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13066 if (SWIG_arg_fail(1)) SWIG_fail;
13067 {
13068 arg2 = &temp2;
13069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13070 }
13071 {
13072 arg3 = &temp3;
13073 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13074 }
13075 if (obj3) {
13076 {
13077 arg4 = static_cast<int >(SWIG_As_int(obj3));
13078 if (SWIG_arg_fail(4)) SWIG_fail;
13079 }
13080 }
13081 if (obj4) {
13082 {
13083 arg5 = static_cast<int >(SWIG_As_int(obj4));
13084 if (SWIG_arg_fail(5)) SWIG_fail;
13085 }
13086 }
13087 if (obj5) {
13088 {
13089 arg6 = static_cast<int >(SWIG_As_int(obj5));
13090 if (SWIG_arg_fail(6)) SWIG_fail;
13091 }
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13096
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 {
13101 wxImage * resultptr;
13102 resultptr = new wxImage(static_cast<wxImage & >(result));
13103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13104 }
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj = NULL;
13113 wxImage *arg1 = (wxImage *) 0 ;
13114 SwigValueWrapper<wxImage > result;
13115 PyObject * obj0 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (arg1)->Copy();
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 wxImage * resultptr;
13132 resultptr = new wxImage(static_cast<wxImage & >(result));
13133 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13134 }
13135 return resultobj;
13136 fail:
13137 return NULL;
13138 }
13139
13140
13141 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13142 PyObject *resultobj = NULL;
13143 wxImage *arg1 = (wxImage *) 0 ;
13144 wxImage *arg2 = 0 ;
13145 int arg3 ;
13146 int arg4 ;
13147 PyObject * obj0 = 0 ;
13148 PyObject * obj1 = 0 ;
13149 PyObject * obj2 = 0 ;
13150 PyObject * obj3 = 0 ;
13151 char *kwnames[] = {
13152 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13153 };
13154
13155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13157 if (SWIG_arg_fail(1)) SWIG_fail;
13158 {
13159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13160 if (SWIG_arg_fail(2)) SWIG_fail;
13161 if (arg2 == NULL) {
13162 SWIG_null_ref("wxImage");
13163 }
13164 if (SWIG_arg_fail(2)) SWIG_fail;
13165 }
13166 {
13167 arg3 = static_cast<int >(SWIG_As_int(obj2));
13168 if (SWIG_arg_fail(3)) SWIG_fail;
13169 }
13170 {
13171 arg4 = static_cast<int >(SWIG_As_int(obj3));
13172 if (SWIG_arg_fail(4)) SWIG_fail;
13173 }
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13177
13178 wxPyEndAllowThreads(__tstate);
13179 if (PyErr_Occurred()) SWIG_fail;
13180 }
13181 Py_INCREF(Py_None); resultobj = Py_None;
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj = NULL;
13190 wxImage *arg1 = (wxImage *) 0 ;
13191 PyObject *result;
13192 PyObject * obj0 = 0 ;
13193 char *kwnames[] = {
13194 (char *) "self", NULL
13195 };
13196
13197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13199 if (SWIG_arg_fail(1)) SWIG_fail;
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 result = (PyObject *)wxImage_GetData(arg1);
13203
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 resultobj = result;
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = NULL;
13216 wxImage *arg1 = (wxImage *) 0 ;
13217 buffer arg2 ;
13218 int arg3 ;
13219 PyObject * obj0 = 0 ;
13220 PyObject * obj1 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self",(char *) "data", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(1)) SWIG_fail;
13228 {
13229 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13230 }
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 wxImage_SetData(arg1,arg2,arg3);
13234
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 Py_INCREF(Py_None); resultobj = Py_None;
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj = NULL;
13247 wxImage *arg1 = (wxImage *) 0 ;
13248 PyObject *result;
13249 PyObject * obj0 = 0 ;
13250 char *kwnames[] = {
13251 (char *) "self", NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13256 if (SWIG_arg_fail(1)) SWIG_fail;
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 resultobj = result;
13265 return resultobj;
13266 fail:
13267 return NULL;
13268 }
13269
13270
13271 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13272 PyObject *resultobj = NULL;
13273 wxImage *arg1 = (wxImage *) 0 ;
13274 buffer arg2 ;
13275 int arg3 ;
13276 PyObject * obj0 = 0 ;
13277 PyObject * obj1 = 0 ;
13278 char *kwnames[] = {
13279 (char *) "self",(char *) "data", NULL
13280 };
13281
13282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13284 if (SWIG_arg_fail(1)) SWIG_fail;
13285 {
13286 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 wxImage_SetDataBuffer(arg1,arg2,arg3);
13291
13292 wxPyEndAllowThreads(__tstate);
13293 if (PyErr_Occurred()) SWIG_fail;
13294 }
13295 Py_INCREF(Py_None); resultobj = Py_None;
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13303 PyObject *resultobj = NULL;
13304 wxImage *arg1 = (wxImage *) 0 ;
13305 PyObject *result;
13306 PyObject * obj0 = 0 ;
13307 char *kwnames[] = {
13308 (char *) "self", NULL
13309 };
13310
13311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13313 if (SWIG_arg_fail(1)) SWIG_fail;
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = (PyObject *)wxImage_GetAlphaData(arg1);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 resultobj = result;
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = NULL;
13330 wxImage *arg1 = (wxImage *) 0 ;
13331 buffer arg2 ;
13332 int arg3 ;
13333 PyObject * obj0 = 0 ;
13334 PyObject * obj1 = 0 ;
13335 char *kwnames[] = {
13336 (char *) "self",(char *) "alpha", NULL
13337 };
13338
13339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13341 if (SWIG_arg_fail(1)) SWIG_fail;
13342 {
13343 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13344 }
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 wxImage_SetAlphaData(arg1,arg2,arg3);
13348
13349 wxPyEndAllowThreads(__tstate);
13350 if (PyErr_Occurred()) SWIG_fail;
13351 }
13352 Py_INCREF(Py_None); resultobj = Py_None;
13353 return resultobj;
13354 fail:
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj = NULL;
13361 wxImage *arg1 = (wxImage *) 0 ;
13362 PyObject *result;
13363 PyObject * obj0 = 0 ;
13364 char *kwnames[] = {
13365 (char *) "self", NULL
13366 };
13367
13368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13370 if (SWIG_arg_fail(1)) SWIG_fail;
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13374
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = result;
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj = NULL;
13387 wxImage *arg1 = (wxImage *) 0 ;
13388 buffer arg2 ;
13389 int arg3 ;
13390 PyObject * obj0 = 0 ;
13391 PyObject * obj1 = 0 ;
13392 char *kwnames[] = {
13393 (char *) "self",(char *) "alpha", NULL
13394 };
13395
13396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13398 if (SWIG_arg_fail(1)) SWIG_fail;
13399 {
13400 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13401 }
13402 {
13403 PyThreadState* __tstate = wxPyBeginAllowThreads();
13404 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13405
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 Py_INCREF(Py_None); resultobj = Py_None;
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj = NULL;
13418 wxImage *arg1 = (wxImage *) 0 ;
13419 byte arg2 ;
13420 byte arg3 ;
13421 byte arg4 ;
13422 PyObject * obj0 = 0 ;
13423 PyObject * obj1 = 0 ;
13424 PyObject * obj2 = 0 ;
13425 PyObject * obj3 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13432 if (SWIG_arg_fail(1)) SWIG_fail;
13433 {
13434 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13435 if (SWIG_arg_fail(2)) SWIG_fail;
13436 }
13437 {
13438 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13439 if (SWIG_arg_fail(3)) SWIG_fail;
13440 }
13441 {
13442 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13443 if (SWIG_arg_fail(4)) SWIG_fail;
13444 }
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 (arg1)->SetMaskColour(arg2,arg3,arg4);
13448
13449 wxPyEndAllowThreads(__tstate);
13450 if (PyErr_Occurred()) SWIG_fail;
13451 }
13452 Py_INCREF(Py_None); resultobj = Py_None;
13453 return resultobj;
13454 fail:
13455 return NULL;
13456 }
13457
13458
13459 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13460 PyObject *resultobj = NULL;
13461 wxImage *arg1 = (wxImage *) 0 ;
13462 byte *arg2 = (byte *) 0 ;
13463 byte *arg3 = (byte *) 0 ;
13464 byte *arg4 = (byte *) 0 ;
13465 byte temp2 ;
13466 int res2 = 0 ;
13467 byte temp3 ;
13468 int res3 = 0 ;
13469 byte temp4 ;
13470 int res4 = 0 ;
13471 PyObject * obj0 = 0 ;
13472 char *kwnames[] = {
13473 (char *) "self", NULL
13474 };
13475
13476 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13477 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13478 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13481 if (SWIG_arg_fail(1)) SWIG_fail;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13485
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 Py_INCREF(Py_None); resultobj = Py_None;
13490 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13491 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13492 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13493 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13494 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13495 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13496 return resultobj;
13497 fail:
13498 return NULL;
13499 }
13500
13501
13502 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj = NULL;
13504 wxImage *arg1 = (wxImage *) 0 ;
13505 byte result;
13506 PyObject * obj0 = 0 ;
13507 char *kwnames[] = {
13508 (char *) "self", NULL
13509 };
13510
13511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13513 if (SWIG_arg_fail(1)) SWIG_fail;
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (byte)(arg1)->GetMaskRed();
13517
13518 wxPyEndAllowThreads(__tstate);
13519 if (PyErr_Occurred()) SWIG_fail;
13520 }
13521 {
13522 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13523 }
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = NULL;
13532 wxImage *arg1 = (wxImage *) 0 ;
13533 byte result;
13534 PyObject * obj0 = 0 ;
13535 char *kwnames[] = {
13536 (char *) "self", NULL
13537 };
13538
13539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13541 if (SWIG_arg_fail(1)) SWIG_fail;
13542 {
13543 PyThreadState* __tstate = wxPyBeginAllowThreads();
13544 result = (byte)(arg1)->GetMaskGreen();
13545
13546 wxPyEndAllowThreads(__tstate);
13547 if (PyErr_Occurred()) SWIG_fail;
13548 }
13549 {
13550 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13551 }
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = NULL;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 byte result;
13562 PyObject * obj0 = 0 ;
13563 char *kwnames[] = {
13564 (char *) "self", NULL
13565 };
13566
13567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13569 if (SWIG_arg_fail(1)) SWIG_fail;
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 result = (byte)(arg1)->GetMaskBlue();
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 {
13578 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13579 }
13580 return resultobj;
13581 fail:
13582 return NULL;
13583 }
13584
13585
13586 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13587 PyObject *resultobj = NULL;
13588 wxImage *arg1 = (wxImage *) 0 ;
13589 bool arg2 = (bool) true ;
13590 PyObject * obj0 = 0 ;
13591 PyObject * obj1 = 0 ;
13592 char *kwnames[] = {
13593 (char *) "self",(char *) "mask", NULL
13594 };
13595
13596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13598 if (SWIG_arg_fail(1)) SWIG_fail;
13599 if (obj1) {
13600 {
13601 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13602 if (SWIG_arg_fail(2)) SWIG_fail;
13603 }
13604 }
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 (arg1)->SetMask(arg2);
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 Py_INCREF(Py_None); resultobj = Py_None;
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = NULL;
13621 wxImage *arg1 = (wxImage *) 0 ;
13622 bool result;
13623 PyObject * obj0 = 0 ;
13624 char *kwnames[] = {
13625 (char *) "self", NULL
13626 };
13627
13628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13630 if (SWIG_arg_fail(1)) SWIG_fail;
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 result = (bool)(arg1)->HasMask();
13634
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 {
13639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13640 }
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj = NULL;
13649 wxImage *arg1 = (wxImage *) 0 ;
13650 double arg2 ;
13651 wxPoint *arg3 = 0 ;
13652 bool arg4 = (bool) true ;
13653 wxPoint *arg5 = (wxPoint *) NULL ;
13654 SwigValueWrapper<wxImage > result;
13655 wxPoint temp3 ;
13656 PyObject * obj0 = 0 ;
13657 PyObject * obj1 = 0 ;
13658 PyObject * obj2 = 0 ;
13659 PyObject * obj3 = 0 ;
13660 PyObject * obj4 = 0 ;
13661 char *kwnames[] = {
13662 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13663 };
13664
13665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13667 if (SWIG_arg_fail(1)) SWIG_fail;
13668 {
13669 arg2 = static_cast<double >(SWIG_As_double(obj1));
13670 if (SWIG_arg_fail(2)) SWIG_fail;
13671 }
13672 {
13673 arg3 = &temp3;
13674 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13675 }
13676 if (obj3) {
13677 {
13678 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13679 if (SWIG_arg_fail(4)) SWIG_fail;
13680 }
13681 }
13682 if (obj4) {
13683 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13684 if (SWIG_arg_fail(5)) SWIG_fail;
13685 }
13686 {
13687 PyThreadState* __tstate = wxPyBeginAllowThreads();
13688 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13689
13690 wxPyEndAllowThreads(__tstate);
13691 if (PyErr_Occurred()) SWIG_fail;
13692 }
13693 {
13694 wxImage * resultptr;
13695 resultptr = new wxImage(static_cast<wxImage & >(result));
13696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13697 }
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj = NULL;
13706 wxImage *arg1 = (wxImage *) 0 ;
13707 bool arg2 = (bool) true ;
13708 SwigValueWrapper<wxImage > result;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 char *kwnames[] = {
13712 (char *) "self",(char *) "clockwise", NULL
13713 };
13714
13715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13717 if (SWIG_arg_fail(1)) SWIG_fail;
13718 if (obj1) {
13719 {
13720 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13721 if (SWIG_arg_fail(2)) SWIG_fail;
13722 }
13723 }
13724 {
13725 PyThreadState* __tstate = wxPyBeginAllowThreads();
13726 result = (arg1)->Rotate90(arg2);
13727
13728 wxPyEndAllowThreads(__tstate);
13729 if (PyErr_Occurred()) SWIG_fail;
13730 }
13731 {
13732 wxImage * resultptr;
13733 resultptr = new wxImage(static_cast<wxImage & >(result));
13734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13735 }
13736 return resultobj;
13737 fail:
13738 return NULL;
13739 }
13740
13741
13742 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj = NULL;
13744 wxImage *arg1 = (wxImage *) 0 ;
13745 bool arg2 = (bool) true ;
13746 SwigValueWrapper<wxImage > result;
13747 PyObject * obj0 = 0 ;
13748 PyObject * obj1 = 0 ;
13749 char *kwnames[] = {
13750 (char *) "self",(char *) "horizontally", NULL
13751 };
13752
13753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13755 if (SWIG_arg_fail(1)) SWIG_fail;
13756 if (obj1) {
13757 {
13758 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13759 if (SWIG_arg_fail(2)) SWIG_fail;
13760 }
13761 }
13762 {
13763 PyThreadState* __tstate = wxPyBeginAllowThreads();
13764 result = (arg1)->Mirror(arg2);
13765
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 {
13770 wxImage * resultptr;
13771 resultptr = new wxImage(static_cast<wxImage & >(result));
13772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13773 }
13774 return resultobj;
13775 fail:
13776 return NULL;
13777 }
13778
13779
13780 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13781 PyObject *resultobj = NULL;
13782 wxImage *arg1 = (wxImage *) 0 ;
13783 byte arg2 ;
13784 byte arg3 ;
13785 byte arg4 ;
13786 byte arg5 ;
13787 byte arg6 ;
13788 byte arg7 ;
13789 PyObject * obj0 = 0 ;
13790 PyObject * obj1 = 0 ;
13791 PyObject * obj2 = 0 ;
13792 PyObject * obj3 = 0 ;
13793 PyObject * obj4 = 0 ;
13794 PyObject * obj5 = 0 ;
13795 PyObject * obj6 = 0 ;
13796 char *kwnames[] = {
13797 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13798 };
13799
13800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13802 if (SWIG_arg_fail(1)) SWIG_fail;
13803 {
13804 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13805 if (SWIG_arg_fail(2)) SWIG_fail;
13806 }
13807 {
13808 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13809 if (SWIG_arg_fail(3)) SWIG_fail;
13810 }
13811 {
13812 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13813 if (SWIG_arg_fail(4)) SWIG_fail;
13814 }
13815 {
13816 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13817 if (SWIG_arg_fail(5)) SWIG_fail;
13818 }
13819 {
13820 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13821 if (SWIG_arg_fail(6)) SWIG_fail;
13822 }
13823 {
13824 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13825 if (SWIG_arg_fail(7)) SWIG_fail;
13826 }
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13830
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 Py_INCREF(Py_None); resultobj = Py_None;
13835 return resultobj;
13836 fail:
13837 return NULL;
13838 }
13839
13840
13841 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj = NULL;
13843 wxImage *arg1 = (wxImage *) 0 ;
13844 double arg2 = (double) 0.299 ;
13845 double arg3 = (double) 0.587 ;
13846 double arg4 = (double) 0.114 ;
13847 SwigValueWrapper<wxImage > result;
13848 PyObject * obj0 = 0 ;
13849 PyObject * obj1 = 0 ;
13850 PyObject * obj2 = 0 ;
13851 PyObject * obj3 = 0 ;
13852 char *kwnames[] = {
13853 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13858 if (SWIG_arg_fail(1)) SWIG_fail;
13859 if (obj1) {
13860 {
13861 arg2 = static_cast<double >(SWIG_As_double(obj1));
13862 if (SWIG_arg_fail(2)) SWIG_fail;
13863 }
13864 }
13865 if (obj2) {
13866 {
13867 arg3 = static_cast<double >(SWIG_As_double(obj2));
13868 if (SWIG_arg_fail(3)) SWIG_fail;
13869 }
13870 }
13871 if (obj3) {
13872 {
13873 arg4 = static_cast<double >(SWIG_As_double(obj3));
13874 if (SWIG_arg_fail(4)) SWIG_fail;
13875 }
13876 }
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13880
13881 wxPyEndAllowThreads(__tstate);
13882 if (PyErr_Occurred()) SWIG_fail;
13883 }
13884 {
13885 wxImage * resultptr;
13886 resultptr = new wxImage(static_cast<wxImage & >(result));
13887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13888 }
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13896 PyObject *resultobj = NULL;
13897 wxImage *arg1 = (wxImage *) 0 ;
13898 byte arg2 ;
13899 byte arg3 ;
13900 byte arg4 ;
13901 SwigValueWrapper<wxImage > result;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 PyObject * obj3 = 0 ;
13906 char *kwnames[] = {
13907 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13908 };
13909
13910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13912 if (SWIG_arg_fail(1)) SWIG_fail;
13913 {
13914 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13915 if (SWIG_arg_fail(2)) SWIG_fail;
13916 }
13917 {
13918 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13919 if (SWIG_arg_fail(3)) SWIG_fail;
13920 }
13921 {
13922 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13923 if (SWIG_arg_fail(4)) SWIG_fail;
13924 }
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13928
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 {
13933 wxImage * resultptr;
13934 resultptr = new wxImage(static_cast<wxImage & >(result));
13935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13936 }
13937 return resultobj;
13938 fail:
13939 return NULL;
13940 }
13941
13942
13943 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13944 PyObject *resultobj = NULL;
13945 wxImage *arg1 = (wxImage *) 0 ;
13946 wxString *arg2 = 0 ;
13947 wxString *arg3 = 0 ;
13948 bool temp2 = false ;
13949 bool temp3 = false ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 PyObject * obj2 = 0 ;
13953 char *kwnames[] = {
13954 (char *) "self",(char *) "name",(char *) "value", NULL
13955 };
13956
13957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(1)) SWIG_fail;
13960 {
13961 arg2 = wxString_in_helper(obj1);
13962 if (arg2 == NULL) SWIG_fail;
13963 temp2 = true;
13964 }
13965 {
13966 arg3 = wxString_in_helper(obj2);
13967 if (arg3 == NULL) SWIG_fail;
13968 temp3 = true;
13969 }
13970 {
13971 PyThreadState* __tstate = wxPyBeginAllowThreads();
13972 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13973
13974 wxPyEndAllowThreads(__tstate);
13975 if (PyErr_Occurred()) SWIG_fail;
13976 }
13977 Py_INCREF(Py_None); resultobj = Py_None;
13978 {
13979 if (temp2)
13980 delete arg2;
13981 }
13982 {
13983 if (temp3)
13984 delete arg3;
13985 }
13986 return resultobj;
13987 fail:
13988 {
13989 if (temp2)
13990 delete arg2;
13991 }
13992 {
13993 if (temp3)
13994 delete arg3;
13995 }
13996 return NULL;
13997 }
13998
13999
14000 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14001 PyObject *resultobj = NULL;
14002 wxImage *arg1 = (wxImage *) 0 ;
14003 wxString *arg2 = 0 ;
14004 int arg3 ;
14005 bool temp2 = false ;
14006 PyObject * obj0 = 0 ;
14007 PyObject * obj1 = 0 ;
14008 PyObject * obj2 = 0 ;
14009 char *kwnames[] = {
14010 (char *) "self",(char *) "name",(char *) "value", NULL
14011 };
14012
14013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14015 if (SWIG_arg_fail(1)) SWIG_fail;
14016 {
14017 arg2 = wxString_in_helper(obj1);
14018 if (arg2 == NULL) SWIG_fail;
14019 temp2 = true;
14020 }
14021 {
14022 arg3 = static_cast<int >(SWIG_As_int(obj2));
14023 if (SWIG_arg_fail(3)) SWIG_fail;
14024 }
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 (arg1)->SetOption((wxString const &)*arg2,arg3);
14028
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 Py_INCREF(Py_None); resultobj = Py_None;
14033 {
14034 if (temp2)
14035 delete arg2;
14036 }
14037 return resultobj;
14038 fail:
14039 {
14040 if (temp2)
14041 delete arg2;
14042 }
14043 return NULL;
14044 }
14045
14046
14047 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14048 PyObject *resultobj = NULL;
14049 wxImage *arg1 = (wxImage *) 0 ;
14050 wxString *arg2 = 0 ;
14051 wxString result;
14052 bool temp2 = false ;
14053 PyObject * obj0 = 0 ;
14054 PyObject * obj1 = 0 ;
14055 char *kwnames[] = {
14056 (char *) "self",(char *) "name", NULL
14057 };
14058
14059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14061 if (SWIG_arg_fail(1)) SWIG_fail;
14062 {
14063 arg2 = wxString_in_helper(obj1);
14064 if (arg2 == NULL) SWIG_fail;
14065 temp2 = true;
14066 }
14067 {
14068 PyThreadState* __tstate = wxPyBeginAllowThreads();
14069 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14070
14071 wxPyEndAllowThreads(__tstate);
14072 if (PyErr_Occurred()) SWIG_fail;
14073 }
14074 {
14075 #if wxUSE_UNICODE
14076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14077 #else
14078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14079 #endif
14080 }
14081 {
14082 if (temp2)
14083 delete arg2;
14084 }
14085 return resultobj;
14086 fail:
14087 {
14088 if (temp2)
14089 delete arg2;
14090 }
14091 return NULL;
14092 }
14093
14094
14095 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj = NULL;
14097 wxImage *arg1 = (wxImage *) 0 ;
14098 wxString *arg2 = 0 ;
14099 int result;
14100 bool temp2 = false ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 char *kwnames[] = {
14104 (char *) "self",(char *) "name", NULL
14105 };
14106
14107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14109 if (SWIG_arg_fail(1)) SWIG_fail;
14110 {
14111 arg2 = wxString_in_helper(obj1);
14112 if (arg2 == NULL) SWIG_fail;
14113 temp2 = true;
14114 }
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 {
14123 resultobj = SWIG_From_int(static_cast<int >(result));
14124 }
14125 {
14126 if (temp2)
14127 delete arg2;
14128 }
14129 return resultobj;
14130 fail:
14131 {
14132 if (temp2)
14133 delete arg2;
14134 }
14135 return NULL;
14136 }
14137
14138
14139 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14140 PyObject *resultobj = NULL;
14141 wxImage *arg1 = (wxImage *) 0 ;
14142 wxString *arg2 = 0 ;
14143 bool result;
14144 bool temp2 = false ;
14145 PyObject * obj0 = 0 ;
14146 PyObject * obj1 = 0 ;
14147 char *kwnames[] = {
14148 (char *) "self",(char *) "name", NULL
14149 };
14150
14151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(1)) SWIG_fail;
14154 {
14155 arg2 = wxString_in_helper(obj1);
14156 if (arg2 == NULL) SWIG_fail;
14157 temp2 = true;
14158 }
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14162
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 {
14167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14168 }
14169 {
14170 if (temp2)
14171 delete arg2;
14172 }
14173 return resultobj;
14174 fail:
14175 {
14176 if (temp2)
14177 delete arg2;
14178 }
14179 return NULL;
14180 }
14181
14182
14183 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14184 PyObject *resultobj = NULL;
14185 wxImage *arg1 = (wxImage *) 0 ;
14186 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14187 unsigned long result;
14188 PyObject * obj0 = 0 ;
14189 PyObject * obj1 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self",(char *) "stopafter", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 if (obj1) {
14198 {
14199 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14200 if (SWIG_arg_fail(2)) SWIG_fail;
14201 }
14202 }
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 result = (unsigned long)(arg1)->CountColours(arg2);
14206
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 {
14211 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14212 }
14213 return resultobj;
14214 fail:
14215 return NULL;
14216 }
14217
14218
14219 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14220 PyObject *resultobj = NULL;
14221 wxImage *arg1 = (wxImage *) 0 ;
14222 wxImageHistogram *arg2 = 0 ;
14223 unsigned long result;
14224 PyObject * obj0 = 0 ;
14225 PyObject * obj1 = 0 ;
14226 char *kwnames[] = {
14227 (char *) "self",(char *) "h", NULL
14228 };
14229
14230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14232 if (SWIG_arg_fail(1)) SWIG_fail;
14233 {
14234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(2)) SWIG_fail;
14236 if (arg2 == NULL) {
14237 SWIG_null_ref("wxImageHistogram");
14238 }
14239 if (SWIG_arg_fail(2)) SWIG_fail;
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14244
14245 wxPyEndAllowThreads(__tstate);
14246 if (PyErr_Occurred()) SWIG_fail;
14247 }
14248 {
14249 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14250 }
14251 return resultobj;
14252 fail:
14253 return NULL;
14254 }
14255
14256
14257 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14258 PyObject *resultobj = NULL;
14259 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14260 PyObject * obj0 = 0 ;
14261 char *kwnames[] = {
14262 (char *) "handler", NULL
14263 };
14264
14265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14267 if (SWIG_arg_fail(1)) SWIG_fail;
14268 {
14269 PyThreadState* __tstate = wxPyBeginAllowThreads();
14270 wxImage::AddHandler(arg1);
14271
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 Py_INCREF(Py_None); resultobj = Py_None;
14276 return resultobj;
14277 fail:
14278 return NULL;
14279 }
14280
14281
14282 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj = NULL;
14284 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14285 PyObject * obj0 = 0 ;
14286 char *kwnames[] = {
14287 (char *) "handler", NULL
14288 };
14289
14290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14292 if (SWIG_arg_fail(1)) SWIG_fail;
14293 {
14294 PyThreadState* __tstate = wxPyBeginAllowThreads();
14295 wxImage::InsertHandler(arg1);
14296
14297 wxPyEndAllowThreads(__tstate);
14298 if (PyErr_Occurred()) SWIG_fail;
14299 }
14300 Py_INCREF(Py_None); resultobj = Py_None;
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14308 PyObject *resultobj = NULL;
14309 wxString *arg1 = 0 ;
14310 bool result;
14311 bool temp1 = false ;
14312 PyObject * obj0 = 0 ;
14313 char *kwnames[] = {
14314 (char *) "name", NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14318 {
14319 arg1 = wxString_in_helper(obj0);
14320 if (arg1 == NULL) SWIG_fail;
14321 temp1 = true;
14322 }
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14326
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 {
14331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14332 }
14333 {
14334 if (temp1)
14335 delete arg1;
14336 }
14337 return resultobj;
14338 fail:
14339 {
14340 if (temp1)
14341 delete arg1;
14342 }
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = NULL;
14349 wxString result;
14350 char *kwnames[] = {
14351 NULL
14352 };
14353
14354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14355 {
14356 PyThreadState* __tstate = wxPyBeginAllowThreads();
14357 result = wxImage::GetImageExtWildcard();
14358
14359 wxPyEndAllowThreads(__tstate);
14360 if (PyErr_Occurred()) SWIG_fail;
14361 }
14362 {
14363 #if wxUSE_UNICODE
14364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14365 #else
14366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14367 #endif
14368 }
14369 return resultobj;
14370 fail:
14371 return NULL;
14372 }
14373
14374
14375 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14376 PyObject *resultobj = NULL;
14377 wxImage *arg1 = (wxImage *) 0 ;
14378 int arg2 = (int) -1 ;
14379 wxBitmap result;
14380 PyObject * obj0 = 0 ;
14381 PyObject * obj1 = 0 ;
14382 char *kwnames[] = {
14383 (char *) "self",(char *) "depth", NULL
14384 };
14385
14386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14388 if (SWIG_arg_fail(1)) SWIG_fail;
14389 if (obj1) {
14390 {
14391 arg2 = static_cast<int >(SWIG_As_int(obj1));
14392 if (SWIG_arg_fail(2)) SWIG_fail;
14393 }
14394 }
14395 {
14396 if (!wxPyCheckForApp()) SWIG_fail;
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = wxImage_ConvertToBitmap(arg1,arg2);
14399
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 wxBitmap * resultptr;
14405 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14406 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14407 }
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = NULL;
14416 wxImage *arg1 = (wxImage *) 0 ;
14417 byte arg2 ;
14418 byte arg3 ;
14419 byte arg4 ;
14420 wxBitmap result;
14421 PyObject * obj0 = 0 ;
14422 PyObject * obj1 = 0 ;
14423 PyObject * obj2 = 0 ;
14424 PyObject * obj3 = 0 ;
14425 char *kwnames[] = {
14426 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14427 };
14428
14429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14431 if (SWIG_arg_fail(1)) SWIG_fail;
14432 {
14433 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14434 if (SWIG_arg_fail(2)) SWIG_fail;
14435 }
14436 {
14437 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14438 if (SWIG_arg_fail(3)) SWIG_fail;
14439 }
14440 {
14441 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14442 if (SWIG_arg_fail(4)) SWIG_fail;
14443 }
14444 {
14445 if (!wxPyCheckForApp()) SWIG_fail;
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14448
14449 wxPyEndAllowThreads(__tstate);
14450 if (PyErr_Occurred()) SWIG_fail;
14451 }
14452 {
14453 wxBitmap * resultptr;
14454 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14456 }
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj = NULL;
14465 wxImage *arg1 = (wxImage *) 0 ;
14466 double arg2 ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char *kwnames[] = {
14470 (char *) "self",(char *) "angle", NULL
14471 };
14472
14473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14475 if (SWIG_arg_fail(1)) SWIG_fail;
14476 {
14477 arg2 = static_cast<double >(SWIG_As_double(obj1));
14478 if (SWIG_arg_fail(2)) SWIG_fail;
14479 }
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 (arg1)->RotateHue(arg2);
14483
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 Py_INCREF(Py_None); resultobj = Py_None;
14488 return resultobj;
14489 fail:
14490 return NULL;
14491 }
14492
14493
14494 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14495 PyObject *resultobj = NULL;
14496 wxImage_RGBValue arg1 ;
14497 wxImage_HSVValue result;
14498 PyObject * obj0 = 0 ;
14499 char *kwnames[] = {
14500 (char *) "rgb", NULL
14501 };
14502
14503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14504 {
14505 wxImage_RGBValue * argp;
14506 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14507 if (SWIG_arg_fail(1)) SWIG_fail;
14508 if (argp == NULL) {
14509 SWIG_null_ref("wxImage_RGBValue");
14510 }
14511 if (SWIG_arg_fail(1)) SWIG_fail;
14512 arg1 = *argp;
14513 }
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = wxImage::RGBtoHSV(arg1);
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 {
14522 wxImage_HSVValue * resultptr;
14523 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14525 }
14526 return resultobj;
14527 fail:
14528 return NULL;
14529 }
14530
14531
14532 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14533 PyObject *resultobj = NULL;
14534 wxImage_HSVValue arg1 ;
14535 wxImage_RGBValue result;
14536 PyObject * obj0 = 0 ;
14537 char *kwnames[] = {
14538 (char *) "hsv", NULL
14539 };
14540
14541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14542 {
14543 wxImage_HSVValue * argp;
14544 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14545 if (SWIG_arg_fail(1)) SWIG_fail;
14546 if (argp == NULL) {
14547 SWIG_null_ref("wxImage_HSVValue");
14548 }
14549 if (SWIG_arg_fail(1)) SWIG_fail;
14550 arg1 = *argp;
14551 }
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 result = wxImage::HSVtoRGB(arg1);
14555
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 {
14560 wxImage_RGBValue * resultptr;
14561 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14563 }
14564 return resultobj;
14565 fail:
14566 return NULL;
14567 }
14568
14569
14570 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14571 PyObject *obj;
14572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14573 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14574 Py_INCREF(obj);
14575 return Py_BuildValue((char *)"");
14576 }
14577 static int _wrap_NullImage_set(PyObject *) {
14578 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14579 return 1;
14580 }
14581
14582
14583 static PyObject *_wrap_NullImage_get(void) {
14584 PyObject *pyobj = NULL;
14585
14586 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14587 return pyobj;
14588 }
14589
14590
14591 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14592 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14593 return 1;
14594 }
14595
14596
14597 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14598 PyObject *pyobj = NULL;
14599
14600 {
14601 #if wxUSE_UNICODE
14602 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14603 #else
14604 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14605 #endif
14606 }
14607 return pyobj;
14608 }
14609
14610
14611 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14612 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14613 return 1;
14614 }
14615
14616
14617 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14618 PyObject *pyobj = NULL;
14619
14620 {
14621 #if wxUSE_UNICODE
14622 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14623 #else
14624 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14625 #endif
14626 }
14627 return pyobj;
14628 }
14629
14630
14631 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14632 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14633 return 1;
14634 }
14635
14636
14637 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14638 PyObject *pyobj = NULL;
14639
14640 {
14641 #if wxUSE_UNICODE
14642 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14643 #else
14644 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14645 #endif
14646 }
14647 return pyobj;
14648 }
14649
14650
14651 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14652 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14653 return 1;
14654 }
14655
14656
14657 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14658 PyObject *pyobj = NULL;
14659
14660 {
14661 #if wxUSE_UNICODE
14662 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14663 #else
14664 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14665 #endif
14666 }
14667 return pyobj;
14668 }
14669
14670
14671 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14672 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14673 return 1;
14674 }
14675
14676
14677 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14678 PyObject *pyobj = NULL;
14679
14680 {
14681 #if wxUSE_UNICODE
14682 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14683 #else
14684 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14685 #endif
14686 }
14687 return pyobj;
14688 }
14689
14690
14691 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14692 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14693 return 1;
14694 }
14695
14696
14697 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14698 PyObject *pyobj = NULL;
14699
14700 {
14701 #if wxUSE_UNICODE
14702 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14703 #else
14704 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14705 #endif
14706 }
14707 return pyobj;
14708 }
14709
14710
14711 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14712 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14713 return 1;
14714 }
14715
14716
14717 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14718 PyObject *pyobj = NULL;
14719
14720 {
14721 #if wxUSE_UNICODE
14722 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14723 #else
14724 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14725 #endif
14726 }
14727 return pyobj;
14728 }
14729
14730
14731 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14732 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14733 return 1;
14734 }
14735
14736
14737 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14738 PyObject *pyobj = NULL;
14739
14740 {
14741 #if wxUSE_UNICODE
14742 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14743 #else
14744 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14745 #endif
14746 }
14747 return pyobj;
14748 }
14749
14750
14751 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14752 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14753 return 1;
14754 }
14755
14756
14757 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14758 PyObject *pyobj = NULL;
14759
14760 {
14761 #if wxUSE_UNICODE
14762 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14763 #else
14764 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14765 #endif
14766 }
14767 return pyobj;
14768 }
14769
14770
14771 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14772 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14773 return 1;
14774 }
14775
14776
14777 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14778 PyObject *pyobj = NULL;
14779
14780 {
14781 #if wxUSE_UNICODE
14782 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14783 #else
14784 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14785 #endif
14786 }
14787 return pyobj;
14788 }
14789
14790
14791 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14792 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14793 return 1;
14794 }
14795
14796
14797 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14798 PyObject *pyobj = NULL;
14799
14800 {
14801 #if wxUSE_UNICODE
14802 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14803 #else
14804 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14805 #endif
14806 }
14807 return pyobj;
14808 }
14809
14810
14811 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14812 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14813 return 1;
14814 }
14815
14816
14817 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14818 PyObject *pyobj = NULL;
14819
14820 {
14821 #if wxUSE_UNICODE
14822 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14823 #else
14824 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14825 #endif
14826 }
14827 return pyobj;
14828 }
14829
14830
14831 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14832 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14833 return 1;
14834 }
14835
14836
14837 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14838 PyObject *pyobj = NULL;
14839
14840 {
14841 #if wxUSE_UNICODE
14842 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14843 #else
14844 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14845 #endif
14846 }
14847 return pyobj;
14848 }
14849
14850
14851 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14852 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14853 return 1;
14854 }
14855
14856
14857 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14858 PyObject *pyobj = NULL;
14859
14860 {
14861 #if wxUSE_UNICODE
14862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14863 #else
14864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14865 #endif
14866 }
14867 return pyobj;
14868 }
14869
14870
14871 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14872 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14873 return 1;
14874 }
14875
14876
14877 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14878 PyObject *pyobj = NULL;
14879
14880 {
14881 #if wxUSE_UNICODE
14882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14883 #else
14884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14885 #endif
14886 }
14887 return pyobj;
14888 }
14889
14890
14891 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14892 PyObject *resultobj = NULL;
14893 wxBMPHandler *result;
14894 char *kwnames[] = {
14895 NULL
14896 };
14897
14898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (wxBMPHandler *)new wxBMPHandler();
14902
14903 wxPyEndAllowThreads(__tstate);
14904 if (PyErr_Occurred()) SWIG_fail;
14905 }
14906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14914 PyObject *obj;
14915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14916 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14917 Py_INCREF(obj);
14918 return Py_BuildValue((char *)"");
14919 }
14920 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj = NULL;
14922 wxICOHandler *result;
14923 char *kwnames[] = {
14924 NULL
14925 };
14926
14927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14928 {
14929 PyThreadState* __tstate = wxPyBeginAllowThreads();
14930 result = (wxICOHandler *)new wxICOHandler();
14931
14932 wxPyEndAllowThreads(__tstate);
14933 if (PyErr_Occurred()) SWIG_fail;
14934 }
14935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14936 return resultobj;
14937 fail:
14938 return NULL;
14939 }
14940
14941
14942 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14943 PyObject *obj;
14944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14945 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14946 Py_INCREF(obj);
14947 return Py_BuildValue((char *)"");
14948 }
14949 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj = NULL;
14951 wxCURHandler *result;
14952 char *kwnames[] = {
14953 NULL
14954 };
14955
14956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 result = (wxCURHandler *)new wxCURHandler();
14960
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14972 PyObject *obj;
14973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14974 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14975 Py_INCREF(obj);
14976 return Py_BuildValue((char *)"");
14977 }
14978 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14979 PyObject *resultobj = NULL;
14980 wxANIHandler *result;
14981 char *kwnames[] = {
14982 NULL
14983 };
14984
14985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 result = (wxANIHandler *)new wxANIHandler();
14989
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14994 return resultobj;
14995 fail:
14996 return NULL;
14997 }
14998
14999
15000 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15001 PyObject *obj;
15002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15003 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15004 Py_INCREF(obj);
15005 return Py_BuildValue((char *)"");
15006 }
15007 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15008 PyObject *resultobj = NULL;
15009 wxPNGHandler *result;
15010 char *kwnames[] = {
15011 NULL
15012 };
15013
15014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 result = (wxPNGHandler *)new wxPNGHandler();
15018
15019 wxPyEndAllowThreads(__tstate);
15020 if (PyErr_Occurred()) SWIG_fail;
15021 }
15022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15030 PyObject *obj;
15031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15032 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15033 Py_INCREF(obj);
15034 return Py_BuildValue((char *)"");
15035 }
15036 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj = NULL;
15038 wxGIFHandler *result;
15039 char *kwnames[] = {
15040 NULL
15041 };
15042
15043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (wxGIFHandler *)new wxGIFHandler();
15047
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15059 PyObject *obj;
15060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15061 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15062 Py_INCREF(obj);
15063 return Py_BuildValue((char *)"");
15064 }
15065 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj = NULL;
15067 wxPCXHandler *result;
15068 char *kwnames[] = {
15069 NULL
15070 };
15071
15072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = (wxPCXHandler *)new wxPCXHandler();
15076
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15088 PyObject *obj;
15089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15090 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15091 Py_INCREF(obj);
15092 return Py_BuildValue((char *)"");
15093 }
15094 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15095 PyObject *resultobj = NULL;
15096 wxJPEGHandler *result;
15097 char *kwnames[] = {
15098 NULL
15099 };
15100
15101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 result = (wxJPEGHandler *)new wxJPEGHandler();
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15117 PyObject *obj;
15118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15119 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15120 Py_INCREF(obj);
15121 return Py_BuildValue((char *)"");
15122 }
15123 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = NULL;
15125 wxPNMHandler *result;
15126 char *kwnames[] = {
15127 NULL
15128 };
15129
15130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15131 {
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 result = (wxPNMHandler *)new wxPNMHandler();
15134
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15139 return resultobj;
15140 fail:
15141 return NULL;
15142 }
15143
15144
15145 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15146 PyObject *obj;
15147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15148 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15149 Py_INCREF(obj);
15150 return Py_BuildValue((char *)"");
15151 }
15152 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15153 PyObject *resultobj = NULL;
15154 wxXPMHandler *result;
15155 char *kwnames[] = {
15156 NULL
15157 };
15158
15159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15160 {
15161 PyThreadState* __tstate = wxPyBeginAllowThreads();
15162 result = (wxXPMHandler *)new wxXPMHandler();
15163
15164 wxPyEndAllowThreads(__tstate);
15165 if (PyErr_Occurred()) SWIG_fail;
15166 }
15167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15175 PyObject *obj;
15176 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15177 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15178 Py_INCREF(obj);
15179 return Py_BuildValue((char *)"");
15180 }
15181 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15182 PyObject *resultobj = NULL;
15183 wxTIFFHandler *result;
15184 char *kwnames[] = {
15185 NULL
15186 };
15187
15188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (wxTIFFHandler *)new wxTIFFHandler();
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15204 PyObject *obj;
15205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15206 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15207 Py_INCREF(obj);
15208 return Py_BuildValue((char *)"");
15209 }
15210 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj = NULL;
15212 wxImage *arg1 = 0 ;
15213 wxImage *arg2 = 0 ;
15214 int arg3 = (int) 236 ;
15215 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15216 bool result;
15217 PyObject * obj0 = 0 ;
15218 PyObject * obj1 = 0 ;
15219 PyObject * obj2 = 0 ;
15220 PyObject * obj3 = 0 ;
15221 char *kwnames[] = {
15222 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15223 };
15224
15225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15226 {
15227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15228 if (SWIG_arg_fail(1)) SWIG_fail;
15229 if (arg1 == NULL) {
15230 SWIG_null_ref("wxImage");
15231 }
15232 if (SWIG_arg_fail(1)) SWIG_fail;
15233 }
15234 {
15235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15236 if (SWIG_arg_fail(2)) SWIG_fail;
15237 if (arg2 == NULL) {
15238 SWIG_null_ref("wxImage");
15239 }
15240 if (SWIG_arg_fail(2)) SWIG_fail;
15241 }
15242 if (obj2) {
15243 {
15244 arg3 = static_cast<int >(SWIG_As_int(obj2));
15245 if (SWIG_arg_fail(3)) SWIG_fail;
15246 }
15247 }
15248 if (obj3) {
15249 {
15250 arg4 = static_cast<int >(SWIG_As_int(obj3));
15251 if (SWIG_arg_fail(4)) SWIG_fail;
15252 }
15253 }
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 {
15262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15263 }
15264 return resultobj;
15265 fail:
15266 return NULL;
15267 }
15268
15269
15270 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15271 PyObject *obj;
15272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15273 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15274 Py_INCREF(obj);
15275 return Py_BuildValue((char *)"");
15276 }
15277 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15278 PyObject *resultobj = NULL;
15279 wxEvtHandler *result;
15280 char *kwnames[] = {
15281 NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = (wxEvtHandler *)new wxEvtHandler();
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj = NULL;
15301 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15302 wxEvtHandler *result;
15303 PyObject * obj0 = 0 ;
15304 char *kwnames[] = {
15305 (char *) "self", NULL
15306 };
15307
15308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15310 if (SWIG_arg_fail(1)) SWIG_fail;
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15314
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 {
15319 resultobj = wxPyMake_wxObject(result, 0);
15320 }
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15328 PyObject *resultobj = NULL;
15329 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15330 wxEvtHandler *result;
15331 PyObject * obj0 = 0 ;
15332 char *kwnames[] = {
15333 (char *) "self", NULL
15334 };
15335
15336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15338 if (SWIG_arg_fail(1)) SWIG_fail;
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15342
15343 wxPyEndAllowThreads(__tstate);
15344 if (PyErr_Occurred()) SWIG_fail;
15345 }
15346 {
15347 resultobj = wxPyMake_wxObject(result, 0);
15348 }
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15356 PyObject *resultobj = NULL;
15357 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15358 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15359 PyObject * obj0 = 0 ;
15360 PyObject * obj1 = 0 ;
15361 char *kwnames[] = {
15362 (char *) "self",(char *) "handler", NULL
15363 };
15364
15365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15367 if (SWIG_arg_fail(1)) SWIG_fail;
15368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(2)) SWIG_fail;
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 (arg1)->SetNextHandler(arg2);
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 Py_INCREF(Py_None); resultobj = Py_None;
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15385 PyObject *resultobj = NULL;
15386 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15387 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15388 PyObject * obj0 = 0 ;
15389 PyObject * obj1 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self",(char *) "handler", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(2)) SWIG_fail;
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 (arg1)->SetPreviousHandler(arg2);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 Py_INCREF(Py_None); resultobj = Py_None;
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj = NULL;
15415 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15416 bool result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (bool)(arg1)->GetEvtHandlerEnabled();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = NULL;
15443 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15444 bool arg2 ;
15445 PyObject * obj0 = 0 ;
15446 PyObject * obj1 = 0 ;
15447 char *kwnames[] = {
15448 (char *) "self",(char *) "enabled", NULL
15449 };
15450
15451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15453 if (SWIG_arg_fail(1)) SWIG_fail;
15454 {
15455 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15456 if (SWIG_arg_fail(2)) SWIG_fail;
15457 }
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 (arg1)->SetEvtHandlerEnabled(arg2);
15461
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 Py_INCREF(Py_None); resultobj = Py_None;
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj = NULL;
15474 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15475 wxEvent *arg2 = 0 ;
15476 bool result;
15477 PyObject * obj0 = 0 ;
15478 PyObject * obj1 = 0 ;
15479 char *kwnames[] = {
15480 (char *) "self",(char *) "event", NULL
15481 };
15482
15483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15485 if (SWIG_arg_fail(1)) SWIG_fail;
15486 {
15487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15488 if (SWIG_arg_fail(2)) SWIG_fail;
15489 if (arg2 == NULL) {
15490 SWIG_null_ref("wxEvent");
15491 }
15492 if (SWIG_arg_fail(2)) SWIG_fail;
15493 }
15494 {
15495 PyThreadState* __tstate = wxPyBeginAllowThreads();
15496 result = (bool)(arg1)->ProcessEvent(*arg2);
15497
15498 wxPyEndAllowThreads(__tstate);
15499 if (PyErr_Occurred()) SWIG_fail;
15500 }
15501 {
15502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15503 }
15504 return resultobj;
15505 fail:
15506 return NULL;
15507 }
15508
15509
15510 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15511 PyObject *resultobj = NULL;
15512 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15513 wxEvent *arg2 = 0 ;
15514 PyObject * obj0 = 0 ;
15515 PyObject * obj1 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self",(char *) "event", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 {
15524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15525 if (SWIG_arg_fail(2)) SWIG_fail;
15526 if (arg2 == NULL) {
15527 SWIG_null_ref("wxEvent");
15528 }
15529 if (SWIG_arg_fail(2)) SWIG_fail;
15530 }
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 (arg1)->AddPendingEvent(*arg2);
15534
15535 wxPyEndAllowThreads(__tstate);
15536 if (PyErr_Occurred()) SWIG_fail;
15537 }
15538 Py_INCREF(Py_None); resultobj = Py_None;
15539 return resultobj;
15540 fail:
15541 return NULL;
15542 }
15543
15544
15545 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15546 PyObject *resultobj = NULL;
15547 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15548 PyObject * obj0 = 0 ;
15549 char *kwnames[] = {
15550 (char *) "self", NULL
15551 };
15552
15553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 (arg1)->ProcessPendingEvents();
15559
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 Py_INCREF(Py_None); resultobj = Py_None;
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15571 PyObject *resultobj = NULL;
15572 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15573 int arg2 ;
15574 int arg3 ;
15575 int arg4 ;
15576 PyObject *arg5 = (PyObject *) 0 ;
15577 PyObject * obj0 = 0 ;
15578 PyObject * obj1 = 0 ;
15579 PyObject * obj2 = 0 ;
15580 PyObject * obj3 = 0 ;
15581 PyObject * obj4 = 0 ;
15582 char *kwnames[] = {
15583 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15584 };
15585
15586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15588 if (SWIG_arg_fail(1)) SWIG_fail;
15589 {
15590 arg2 = static_cast<int >(SWIG_As_int(obj1));
15591 if (SWIG_arg_fail(2)) SWIG_fail;
15592 }
15593 {
15594 arg3 = static_cast<int >(SWIG_As_int(obj2));
15595 if (SWIG_arg_fail(3)) SWIG_fail;
15596 }
15597 {
15598 arg4 = static_cast<int >(SWIG_As_int(obj3));
15599 if (SWIG_arg_fail(4)) SWIG_fail;
15600 }
15601 arg5 = obj4;
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 Py_INCREF(Py_None); resultobj = Py_None;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = NULL;
15618 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15619 int arg2 ;
15620 int arg3 = (int) -1 ;
15621 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15622 bool result;
15623 PyObject * obj0 = 0 ;
15624 PyObject * obj1 = 0 ;
15625 PyObject * obj2 = 0 ;
15626 PyObject * obj3 = 0 ;
15627 char *kwnames[] = {
15628 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15629 };
15630
15631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15633 if (SWIG_arg_fail(1)) SWIG_fail;
15634 {
15635 arg2 = static_cast<int >(SWIG_As_int(obj1));
15636 if (SWIG_arg_fail(2)) SWIG_fail;
15637 }
15638 if (obj2) {
15639 {
15640 arg3 = static_cast<int >(SWIG_As_int(obj2));
15641 if (SWIG_arg_fail(3)) SWIG_fail;
15642 }
15643 }
15644 if (obj3) {
15645 {
15646 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15647 if (SWIG_arg_fail(4)) SWIG_fail;
15648 }
15649 }
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15653
15654 wxPyEndAllowThreads(__tstate);
15655 if (PyErr_Occurred()) SWIG_fail;
15656 }
15657 {
15658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15659 }
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15667 PyObject *resultobj = NULL;
15668 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15669 PyObject *arg2 = (PyObject *) 0 ;
15670 bool arg3 = (bool) true ;
15671 PyObject * obj0 = 0 ;
15672 PyObject * obj1 = 0 ;
15673 PyObject * obj2 = 0 ;
15674 char *kwnames[] = {
15675 (char *) "self",(char *) "_self",(char *) "incref", NULL
15676 };
15677
15678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15680 if (SWIG_arg_fail(1)) SWIG_fail;
15681 arg2 = obj1;
15682 if (obj2) {
15683 {
15684 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15685 if (SWIG_arg_fail(3)) SWIG_fail;
15686 }
15687 }
15688 {
15689 PyThreadState* __tstate = wxPyBeginAllowThreads();
15690 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15691
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 Py_INCREF(Py_None); resultobj = Py_None;
15696 return resultobj;
15697 fail:
15698 return NULL;
15699 }
15700
15701
15702 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15703 PyObject *obj;
15704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15705 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15706 Py_INCREF(obj);
15707 return Py_BuildValue((char *)"");
15708 }
15709 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15710 PyObject *resultobj = NULL;
15711 wxEventType result;
15712 char *kwnames[] = {
15713 NULL
15714 };
15715
15716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 result = (wxEventType)wxNewEventType();
15720
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 {
15725 resultobj = SWIG_From_int(static_cast<int >(result));
15726 }
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj = NULL;
15735 wxEvent *arg1 = (wxEvent *) 0 ;
15736 PyObject * obj0 = 0 ;
15737 char *kwnames[] = {
15738 (char *) "self", NULL
15739 };
15740
15741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15743 if (SWIG_arg_fail(1)) SWIG_fail;
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 delete arg1;
15747
15748 wxPyEndAllowThreads(__tstate);
15749 if (PyErr_Occurred()) SWIG_fail;
15750 }
15751 Py_INCREF(Py_None); resultobj = Py_None;
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15759 PyObject *resultobj = NULL;
15760 wxEvent *arg1 = (wxEvent *) 0 ;
15761 wxEventType arg2 ;
15762 PyObject * obj0 = 0 ;
15763 PyObject * obj1 = 0 ;
15764 char *kwnames[] = {
15765 (char *) "self",(char *) "typ", NULL
15766 };
15767
15768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15770 if (SWIG_arg_fail(1)) SWIG_fail;
15771 {
15772 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15773 if (SWIG_arg_fail(2)) SWIG_fail;
15774 }
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 (arg1)->SetEventType(arg2);
15778
15779 wxPyEndAllowThreads(__tstate);
15780 if (PyErr_Occurred()) SWIG_fail;
15781 }
15782 Py_INCREF(Py_None); resultobj = Py_None;
15783 return resultobj;
15784 fail:
15785 return NULL;
15786 }
15787
15788
15789 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15790 PyObject *resultobj = NULL;
15791 wxEvent *arg1 = (wxEvent *) 0 ;
15792 wxEventType result;
15793 PyObject * obj0 = 0 ;
15794 char *kwnames[] = {
15795 (char *) "self", NULL
15796 };
15797
15798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15800 if (SWIG_arg_fail(1)) SWIG_fail;
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15804
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 {
15809 resultobj = SWIG_From_int(static_cast<int >(result));
15810 }
15811 return resultobj;
15812 fail:
15813 return NULL;
15814 }
15815
15816
15817 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15818 PyObject *resultobj = NULL;
15819 wxEvent *arg1 = (wxEvent *) 0 ;
15820 wxObject *result;
15821 PyObject * obj0 = 0 ;
15822 char *kwnames[] = {
15823 (char *) "self", NULL
15824 };
15825
15826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15828 if (SWIG_arg_fail(1)) SWIG_fail;
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15832
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 {
15837 resultobj = wxPyMake_wxObject(result, 0);
15838 }
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj = NULL;
15847 wxEvent *arg1 = (wxEvent *) 0 ;
15848 wxObject *arg2 = (wxObject *) 0 ;
15849 PyObject * obj0 = 0 ;
15850 PyObject * obj1 = 0 ;
15851 char *kwnames[] = {
15852 (char *) "self",(char *) "obj", NULL
15853 };
15854
15855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15857 if (SWIG_arg_fail(1)) SWIG_fail;
15858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15859 if (SWIG_arg_fail(2)) SWIG_fail;
15860 {
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 (arg1)->SetEventObject(arg2);
15863
15864 wxPyEndAllowThreads(__tstate);
15865 if (PyErr_Occurred()) SWIG_fail;
15866 }
15867 Py_INCREF(Py_None); resultobj = Py_None;
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj = NULL;
15876 wxEvent *arg1 = (wxEvent *) 0 ;
15877 long result;
15878 PyObject * obj0 = 0 ;
15879 char *kwnames[] = {
15880 (char *) "self", NULL
15881 };
15882
15883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15885 if (SWIG_arg_fail(1)) SWIG_fail;
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15889
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 {
15894 resultobj = SWIG_From_long(static_cast<long >(result));
15895 }
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15903 PyObject *resultobj = NULL;
15904 wxEvent *arg1 = (wxEvent *) 0 ;
15905 long arg2 = (long) 0 ;
15906 PyObject * obj0 = 0 ;
15907 PyObject * obj1 = 0 ;
15908 char *kwnames[] = {
15909 (char *) "self",(char *) "ts", NULL
15910 };
15911
15912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15914 if (SWIG_arg_fail(1)) SWIG_fail;
15915 if (obj1) {
15916 {
15917 arg2 = static_cast<long >(SWIG_As_long(obj1));
15918 if (SWIG_arg_fail(2)) SWIG_fail;
15919 }
15920 }
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 (arg1)->SetTimestamp(arg2);
15924
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 Py_INCREF(Py_None); resultobj = Py_None;
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = NULL;
15937 wxEvent *arg1 = (wxEvent *) 0 ;
15938 int result;
15939 PyObject * obj0 = 0 ;
15940 char *kwnames[] = {
15941 (char *) "self", NULL
15942 };
15943
15944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15946 if (SWIG_arg_fail(1)) SWIG_fail;
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 result = (int)((wxEvent const *)arg1)->GetId();
15950
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 {
15955 resultobj = SWIG_From_int(static_cast<int >(result));
15956 }
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj = NULL;
15965 wxEvent *arg1 = (wxEvent *) 0 ;
15966 int arg2 ;
15967 PyObject * obj0 = 0 ;
15968 PyObject * obj1 = 0 ;
15969 char *kwnames[] = {
15970 (char *) "self",(char *) "Id", NULL
15971 };
15972
15973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15975 if (SWIG_arg_fail(1)) SWIG_fail;
15976 {
15977 arg2 = static_cast<int >(SWIG_As_int(obj1));
15978 if (SWIG_arg_fail(2)) SWIG_fail;
15979 }
15980 {
15981 PyThreadState* __tstate = wxPyBeginAllowThreads();
15982 (arg1)->SetId(arg2);
15983
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 Py_INCREF(Py_None); resultobj = Py_None;
15988 return resultobj;
15989 fail:
15990 return NULL;
15991 }
15992
15993
15994 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15995 PyObject *resultobj = NULL;
15996 wxEvent *arg1 = (wxEvent *) 0 ;
15997 bool result;
15998 PyObject * obj0 = 0 ;
15999 char *kwnames[] = {
16000 (char *) "self", NULL
16001 };
16002
16003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16005 if (SWIG_arg_fail(1)) SWIG_fail;
16006 {
16007 PyThreadState* __tstate = wxPyBeginAllowThreads();
16008 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16009
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 {
16014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16015 }
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj = NULL;
16024 wxEvent *arg1 = (wxEvent *) 0 ;
16025 bool arg2 = (bool) true ;
16026 PyObject * obj0 = 0 ;
16027 PyObject * obj1 = 0 ;
16028 char *kwnames[] = {
16029 (char *) "self",(char *) "skip", NULL
16030 };
16031
16032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16034 if (SWIG_arg_fail(1)) SWIG_fail;
16035 if (obj1) {
16036 {
16037 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16038 if (SWIG_arg_fail(2)) SWIG_fail;
16039 }
16040 }
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 (arg1)->Skip(arg2);
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 Py_INCREF(Py_None); resultobj = Py_None;
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16056 PyObject *resultobj = NULL;
16057 wxEvent *arg1 = (wxEvent *) 0 ;
16058 bool result;
16059 PyObject * obj0 = 0 ;
16060 char *kwnames[] = {
16061 (char *) "self", NULL
16062 };
16063
16064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16070
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 {
16075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16076 }
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj = NULL;
16085 wxEvent *arg1 = (wxEvent *) 0 ;
16086 bool result;
16087 PyObject * obj0 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16098
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 {
16103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16104 }
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj = NULL;
16113 wxEvent *arg1 = (wxEvent *) 0 ;
16114 int result;
16115 PyObject * obj0 = 0 ;
16116 char *kwnames[] = {
16117 (char *) "self", NULL
16118 };
16119
16120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16122 if (SWIG_arg_fail(1)) SWIG_fail;
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 result = (int)(arg1)->StopPropagation();
16126
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 {
16131 resultobj = SWIG_From_int(static_cast<int >(result));
16132 }
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16140 PyObject *resultobj = NULL;
16141 wxEvent *arg1 = (wxEvent *) 0 ;
16142 int arg2 ;
16143 PyObject * obj0 = 0 ;
16144 PyObject * obj1 = 0 ;
16145 char *kwnames[] = {
16146 (char *) "self",(char *) "propagationLevel", NULL
16147 };
16148
16149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16151 if (SWIG_arg_fail(1)) SWIG_fail;
16152 {
16153 arg2 = static_cast<int >(SWIG_As_int(obj1));
16154 if (SWIG_arg_fail(2)) SWIG_fail;
16155 }
16156 {
16157 PyThreadState* __tstate = wxPyBeginAllowThreads();
16158 (arg1)->ResumePropagation(arg2);
16159
16160 wxPyEndAllowThreads(__tstate);
16161 if (PyErr_Occurred()) SWIG_fail;
16162 }
16163 Py_INCREF(Py_None); resultobj = Py_None;
16164 return resultobj;
16165 fail:
16166 return NULL;
16167 }
16168
16169
16170 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16171 PyObject *resultobj = NULL;
16172 wxEvent *arg1 = (wxEvent *) 0 ;
16173 wxEvent *result;
16174 PyObject * obj0 = 0 ;
16175 char *kwnames[] = {
16176 (char *) "self", NULL
16177 };
16178
16179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16181 if (SWIG_arg_fail(1)) SWIG_fail;
16182 {
16183 PyThreadState* __tstate = wxPyBeginAllowThreads();
16184 result = (wxEvent *)(arg1)->Clone();
16185
16186 wxPyEndAllowThreads(__tstate);
16187 if (PyErr_Occurred()) SWIG_fail;
16188 }
16189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16190 return resultobj;
16191 fail:
16192 return NULL;
16193 }
16194
16195
16196 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16197 PyObject *obj;
16198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16199 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16200 Py_INCREF(obj);
16201 return Py_BuildValue((char *)"");
16202 }
16203 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16204 PyObject *resultobj = NULL;
16205 wxEvent *arg1 = 0 ;
16206 wxPropagationDisabler *result;
16207 PyObject * obj0 = 0 ;
16208 char *kwnames[] = {
16209 (char *) "event", NULL
16210 };
16211
16212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16213 {
16214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16215 if (SWIG_arg_fail(1)) SWIG_fail;
16216 if (arg1 == NULL) {
16217 SWIG_null_ref("wxEvent");
16218 }
16219 if (SWIG_arg_fail(1)) SWIG_fail;
16220 }
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16224
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj = NULL;
16237 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16238 PyObject * obj0 = 0 ;
16239 char *kwnames[] = {
16240 (char *) "self", NULL
16241 };
16242
16243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16245 if (SWIG_arg_fail(1)) SWIG_fail;
16246 {
16247 PyThreadState* __tstate = wxPyBeginAllowThreads();
16248 delete arg1;
16249
16250 wxPyEndAllowThreads(__tstate);
16251 if (PyErr_Occurred()) SWIG_fail;
16252 }
16253 Py_INCREF(Py_None); resultobj = Py_None;
16254 return resultobj;
16255 fail:
16256 return NULL;
16257 }
16258
16259
16260 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16261 PyObject *obj;
16262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16263 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16264 Py_INCREF(obj);
16265 return Py_BuildValue((char *)"");
16266 }
16267 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16268 PyObject *resultobj = NULL;
16269 wxEvent *arg1 = 0 ;
16270 wxPropagateOnce *result;
16271 PyObject * obj0 = 0 ;
16272 char *kwnames[] = {
16273 (char *) "event", NULL
16274 };
16275
16276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16277 {
16278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16279 if (SWIG_arg_fail(1)) SWIG_fail;
16280 if (arg1 == NULL) {
16281 SWIG_null_ref("wxEvent");
16282 }
16283 if (SWIG_arg_fail(1)) SWIG_fail;
16284 }
16285 {
16286 PyThreadState* __tstate = wxPyBeginAllowThreads();
16287 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16288
16289 wxPyEndAllowThreads(__tstate);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 }
16292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16293 return resultobj;
16294 fail:
16295 return NULL;
16296 }
16297
16298
16299 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16300 PyObject *resultobj = NULL;
16301 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16302 PyObject * obj0 = 0 ;
16303 char *kwnames[] = {
16304 (char *) "self", NULL
16305 };
16306
16307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16309 if (SWIG_arg_fail(1)) SWIG_fail;
16310 {
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 delete arg1;
16313
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 Py_INCREF(Py_None); resultobj = Py_None;
16318 return resultobj;
16319 fail:
16320 return NULL;
16321 }
16322
16323
16324 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16325 PyObject *obj;
16326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16327 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16328 Py_INCREF(obj);
16329 return Py_BuildValue((char *)"");
16330 }
16331 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj = NULL;
16333 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16334 int arg2 = (int) 0 ;
16335 wxCommandEvent *result;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 char *kwnames[] = {
16339 (char *) "commandType",(char *) "winid", NULL
16340 };
16341
16342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16343 if (obj0) {
16344 {
16345 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16346 if (SWIG_arg_fail(1)) SWIG_fail;
16347 }
16348 }
16349 if (obj1) {
16350 {
16351 arg2 = static_cast<int >(SWIG_As_int(obj1));
16352 if (SWIG_arg_fail(2)) SWIG_fail;
16353 }
16354 }
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16358
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj = NULL;
16371 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16372 int result;
16373 PyObject * obj0 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "self", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 resultobj = SWIG_From_int(static_cast<int >(result));
16390 }
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj = NULL;
16399 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16400 wxString *arg2 = 0 ;
16401 bool temp2 = false ;
16402 PyObject * obj0 = 0 ;
16403 PyObject * obj1 = 0 ;
16404 char *kwnames[] = {
16405 (char *) "self",(char *) "s", NULL
16406 };
16407
16408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16410 if (SWIG_arg_fail(1)) SWIG_fail;
16411 {
16412 arg2 = wxString_in_helper(obj1);
16413 if (arg2 == NULL) SWIG_fail;
16414 temp2 = true;
16415 }
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 (arg1)->SetString((wxString const &)*arg2);
16419
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 Py_INCREF(Py_None); resultobj = Py_None;
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return resultobj;
16429 fail:
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 return NULL;
16435 }
16436
16437
16438 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = NULL;
16440 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16441 wxString result;
16442 PyObject * obj0 = 0 ;
16443 char *kwnames[] = {
16444 (char *) "self", NULL
16445 };
16446
16447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16449 if (SWIG_arg_fail(1)) SWIG_fail;
16450 {
16451 PyThreadState* __tstate = wxPyBeginAllowThreads();
16452 result = ((wxCommandEvent const *)arg1)->GetString();
16453
16454 wxPyEndAllowThreads(__tstate);
16455 if (PyErr_Occurred()) SWIG_fail;
16456 }
16457 {
16458 #if wxUSE_UNICODE
16459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16460 #else
16461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16462 #endif
16463 }
16464 return resultobj;
16465 fail:
16466 return NULL;
16467 }
16468
16469
16470 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16471 PyObject *resultobj = NULL;
16472 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16473 bool result;
16474 PyObject * obj0 = 0 ;
16475 char *kwnames[] = {
16476 (char *) "self", NULL
16477 };
16478
16479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16481 if (SWIG_arg_fail(1)) SWIG_fail;
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16485
16486 wxPyEndAllowThreads(__tstate);
16487 if (PyErr_Occurred()) SWIG_fail;
16488 }
16489 {
16490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16491 }
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16499 PyObject *resultobj = NULL;
16500 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16501 bool result;
16502 PyObject * obj0 = 0 ;
16503 char *kwnames[] = {
16504 (char *) "self", NULL
16505 };
16506
16507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16509 if (SWIG_arg_fail(1)) SWIG_fail;
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16513
16514 wxPyEndAllowThreads(__tstate);
16515 if (PyErr_Occurred()) SWIG_fail;
16516 }
16517 {
16518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16519 }
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj = NULL;
16528 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16529 long arg2 ;
16530 PyObject * obj0 = 0 ;
16531 PyObject * obj1 = 0 ;
16532 char *kwnames[] = {
16533 (char *) "self",(char *) "extraLong", NULL
16534 };
16535
16536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16538 if (SWIG_arg_fail(1)) SWIG_fail;
16539 {
16540 arg2 = static_cast<long >(SWIG_As_long(obj1));
16541 if (SWIG_arg_fail(2)) SWIG_fail;
16542 }
16543 {
16544 PyThreadState* __tstate = wxPyBeginAllowThreads();
16545 (arg1)->SetExtraLong(arg2);
16546
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 Py_INCREF(Py_None); resultobj = Py_None;
16551 return resultobj;
16552 fail:
16553 return NULL;
16554 }
16555
16556
16557 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj = NULL;
16559 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16560 long result;
16561 PyObject * obj0 = 0 ;
16562 char *kwnames[] = {
16563 (char *) "self", NULL
16564 };
16565
16566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16568 if (SWIG_arg_fail(1)) SWIG_fail;
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16572
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 {
16577 resultobj = SWIG_From_long(static_cast<long >(result));
16578 }
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj = NULL;
16587 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16588 int arg2 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 char *kwnames[] = {
16592 (char *) "self",(char *) "i", NULL
16593 };
16594
16595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16597 if (SWIG_arg_fail(1)) SWIG_fail;
16598 {
16599 arg2 = static_cast<int >(SWIG_As_int(obj1));
16600 if (SWIG_arg_fail(2)) SWIG_fail;
16601 }
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 (arg1)->SetInt(arg2);
16605
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 Py_INCREF(Py_None); resultobj = Py_None;
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj = NULL;
16618 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16619 long result;
16620 PyObject * obj0 = 0 ;
16621 char *kwnames[] = {
16622 (char *) "self", NULL
16623 };
16624
16625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16627 if (SWIG_arg_fail(1)) SWIG_fail;
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16631
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 {
16636 resultobj = SWIG_From_long(static_cast<long >(result));
16637 }
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = NULL;
16646 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16647 wxEvent *result;
16648 PyObject * obj0 = 0 ;
16649 char *kwnames[] = {
16650 (char *) "self", NULL
16651 };
16652
16653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16655 if (SWIG_arg_fail(1)) SWIG_fail;
16656 {
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16659
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16671 PyObject *obj;
16672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16673 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16674 Py_INCREF(obj);
16675 return Py_BuildValue((char *)"");
16676 }
16677 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16678 PyObject *resultobj = NULL;
16679 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16680 int arg2 = (int) 0 ;
16681 wxNotifyEvent *result;
16682 PyObject * obj0 = 0 ;
16683 PyObject * obj1 = 0 ;
16684 char *kwnames[] = {
16685 (char *) "commandType",(char *) "winid", NULL
16686 };
16687
16688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16689 if (obj0) {
16690 {
16691 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16692 if (SWIG_arg_fail(1)) SWIG_fail;
16693 }
16694 }
16695 if (obj1) {
16696 {
16697 arg2 = static_cast<int >(SWIG_As_int(obj1));
16698 if (SWIG_arg_fail(2)) SWIG_fail;
16699 }
16700 }
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16704
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16716 PyObject *resultobj = NULL;
16717 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16718 PyObject * obj0 = 0 ;
16719 char *kwnames[] = {
16720 (char *) "self", NULL
16721 };
16722
16723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16725 if (SWIG_arg_fail(1)) SWIG_fail;
16726 {
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 (arg1)->Veto();
16729
16730 wxPyEndAllowThreads(__tstate);
16731 if (PyErr_Occurred()) SWIG_fail;
16732 }
16733 Py_INCREF(Py_None); resultobj = Py_None;
16734 return resultobj;
16735 fail:
16736 return NULL;
16737 }
16738
16739
16740 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16741 PyObject *resultobj = NULL;
16742 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16743 PyObject * obj0 = 0 ;
16744 char *kwnames[] = {
16745 (char *) "self", NULL
16746 };
16747
16748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16750 if (SWIG_arg_fail(1)) SWIG_fail;
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 (arg1)->Allow();
16754
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 Py_INCREF(Py_None); resultobj = Py_None;
16759 return resultobj;
16760 fail:
16761 return NULL;
16762 }
16763
16764
16765 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16766 PyObject *resultobj = NULL;
16767 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16768 bool result;
16769 PyObject * obj0 = 0 ;
16770 char *kwnames[] = {
16771 (char *) "self", NULL
16772 };
16773
16774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16776 if (SWIG_arg_fail(1)) SWIG_fail;
16777 {
16778 PyThreadState* __tstate = wxPyBeginAllowThreads();
16779 result = (bool)(arg1)->IsAllowed();
16780
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 {
16785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16786 }
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16794 PyObject *obj;
16795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16796 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16797 Py_INCREF(obj);
16798 return Py_BuildValue((char *)"");
16799 }
16800 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj = NULL;
16802 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16803 int arg2 = (int) 0 ;
16804 int arg3 = (int) 0 ;
16805 int arg4 = (int) 0 ;
16806 wxScrollEvent *result;
16807 PyObject * obj0 = 0 ;
16808 PyObject * obj1 = 0 ;
16809 PyObject * obj2 = 0 ;
16810 PyObject * obj3 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16816 if (obj0) {
16817 {
16818 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 }
16821 }
16822 if (obj1) {
16823 {
16824 arg2 = static_cast<int >(SWIG_As_int(obj1));
16825 if (SWIG_arg_fail(2)) SWIG_fail;
16826 }
16827 }
16828 if (obj2) {
16829 {
16830 arg3 = static_cast<int >(SWIG_As_int(obj2));
16831 if (SWIG_arg_fail(3)) SWIG_fail;
16832 }
16833 }
16834 if (obj3) {
16835 {
16836 arg4 = static_cast<int >(SWIG_As_int(obj3));
16837 if (SWIG_arg_fail(4)) SWIG_fail;
16838 }
16839 }
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16843
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj = NULL;
16856 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16857 int result;
16858 PyObject * obj0 = 0 ;
16859 char *kwnames[] = {
16860 (char *) "self", NULL
16861 };
16862
16863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16865 if (SWIG_arg_fail(1)) SWIG_fail;
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16869
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 {
16874 resultobj = SWIG_From_int(static_cast<int >(result));
16875 }
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj = NULL;
16884 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16885 int result;
16886 PyObject * obj0 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "self", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16893 if (SWIG_arg_fail(1)) SWIG_fail;
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16897
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 {
16902 resultobj = SWIG_From_int(static_cast<int >(result));
16903 }
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj = NULL;
16912 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16913 int arg2 ;
16914 PyObject * obj0 = 0 ;
16915 PyObject * obj1 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self",(char *) "orient", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 {
16924 arg2 = static_cast<int >(SWIG_As_int(obj1));
16925 if (SWIG_arg_fail(2)) SWIG_fail;
16926 }
16927 {
16928 PyThreadState* __tstate = wxPyBeginAllowThreads();
16929 (arg1)->SetOrientation(arg2);
16930
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 Py_INCREF(Py_None); resultobj = Py_None;
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj = NULL;
16943 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16944 int arg2 ;
16945 PyObject * obj0 = 0 ;
16946 PyObject * obj1 = 0 ;
16947 char *kwnames[] = {
16948 (char *) "self",(char *) "pos", NULL
16949 };
16950
16951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16953 if (SWIG_arg_fail(1)) SWIG_fail;
16954 {
16955 arg2 = static_cast<int >(SWIG_As_int(obj1));
16956 if (SWIG_arg_fail(2)) SWIG_fail;
16957 }
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 (arg1)->SetPosition(arg2);
16961
16962 wxPyEndAllowThreads(__tstate);
16963 if (PyErr_Occurred()) SWIG_fail;
16964 }
16965 Py_INCREF(Py_None); resultobj = Py_None;
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16973 PyObject *obj;
16974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16975 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16976 Py_INCREF(obj);
16977 return Py_BuildValue((char *)"");
16978 }
16979 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj = NULL;
16981 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16982 int arg2 = (int) 0 ;
16983 int arg3 = (int) 0 ;
16984 wxScrollWinEvent *result;
16985 PyObject * obj0 = 0 ;
16986 PyObject * obj1 = 0 ;
16987 PyObject * obj2 = 0 ;
16988 char *kwnames[] = {
16989 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16990 };
16991
16992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16993 if (obj0) {
16994 {
16995 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 }
16998 }
16999 if (obj1) {
17000 {
17001 arg2 = static_cast<int >(SWIG_As_int(obj1));
17002 if (SWIG_arg_fail(2)) SWIG_fail;
17003 }
17004 }
17005 if (obj2) {
17006 {
17007 arg3 = static_cast<int >(SWIG_As_int(obj2));
17008 if (SWIG_arg_fail(3)) SWIG_fail;
17009 }
17010 }
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17014
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj = NULL;
17027 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17028 int result;
17029 PyObject * obj0 = 0 ;
17030 char *kwnames[] = {
17031 (char *) "self", NULL
17032 };
17033
17034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17036 if (SWIG_arg_fail(1)) SWIG_fail;
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17040
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 {
17045 resultobj = SWIG_From_int(static_cast<int >(result));
17046 }
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj = NULL;
17055 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17056 int result;
17057 PyObject * obj0 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17068
17069 wxPyEndAllowThreads(__tstate);
17070 if (PyErr_Occurred()) SWIG_fail;
17071 }
17072 {
17073 resultobj = SWIG_From_int(static_cast<int >(result));
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj = NULL;
17083 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17084 int arg2 ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self",(char *) "orient", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 arg2 = static_cast<int >(SWIG_As_int(obj1));
17096 if (SWIG_arg_fail(2)) SWIG_fail;
17097 }
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 (arg1)->SetOrientation(arg2);
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 Py_INCREF(Py_None); resultobj = Py_None;
17106 return resultobj;
17107 fail:
17108 return NULL;
17109 }
17110
17111
17112 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj = NULL;
17114 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17115 int arg2 ;
17116 PyObject * obj0 = 0 ;
17117 PyObject * obj1 = 0 ;
17118 char *kwnames[] = {
17119 (char *) "self",(char *) "pos", NULL
17120 };
17121
17122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17124 if (SWIG_arg_fail(1)) SWIG_fail;
17125 {
17126 arg2 = static_cast<int >(SWIG_As_int(obj1));
17127 if (SWIG_arg_fail(2)) SWIG_fail;
17128 }
17129 {
17130 PyThreadState* __tstate = wxPyBeginAllowThreads();
17131 (arg1)->SetPosition(arg2);
17132
17133 wxPyEndAllowThreads(__tstate);
17134 if (PyErr_Occurred()) SWIG_fail;
17135 }
17136 Py_INCREF(Py_None); resultobj = Py_None;
17137 return resultobj;
17138 fail:
17139 return NULL;
17140 }
17141
17142
17143 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17144 PyObject *obj;
17145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17146 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17147 Py_INCREF(obj);
17148 return Py_BuildValue((char *)"");
17149 }
17150 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj = NULL;
17152 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17153 wxMouseEvent *result;
17154 PyObject * obj0 = 0 ;
17155 char *kwnames[] = {
17156 (char *) "mouseType", NULL
17157 };
17158
17159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17160 if (obj0) {
17161 {
17162 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17163 if (SWIG_arg_fail(1)) SWIG_fail;
17164 }
17165 }
17166 {
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 {
17174 resultobj = wxPyMake_wxObject(result, 1);
17175 }
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj = NULL;
17184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17185 bool result;
17186 PyObject * obj0 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj = NULL;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 int arg2 = (int) wxMOUSE_BTN_ANY ;
17214 bool result;
17215 PyObject * obj0 = 0 ;
17216 PyObject * obj1 = 0 ;
17217 char *kwnames[] = {
17218 (char *) "self",(char *) "but", NULL
17219 };
17220
17221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17223 if (SWIG_arg_fail(1)) SWIG_fail;
17224 if (obj1) {
17225 {
17226 arg2 = static_cast<int >(SWIG_As_int(obj1));
17227 if (SWIG_arg_fail(2)) SWIG_fail;
17228 }
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17233
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 {
17238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17239 }
17240 return resultobj;
17241 fail:
17242 return NULL;
17243 }
17244
17245
17246 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17247 PyObject *resultobj = NULL;
17248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17249 int arg2 = (int) wxMOUSE_BTN_ANY ;
17250 bool result;
17251 PyObject * obj0 = 0 ;
17252 PyObject * obj1 = 0 ;
17253 char *kwnames[] = {
17254 (char *) "self",(char *) "but", NULL
17255 };
17256
17257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17259 if (SWIG_arg_fail(1)) SWIG_fail;
17260 if (obj1) {
17261 {
17262 arg2 = static_cast<int >(SWIG_As_int(obj1));
17263 if (SWIG_arg_fail(2)) SWIG_fail;
17264 }
17265 }
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17269
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj = NULL;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 int arg2 = (int) wxMOUSE_BTN_ANY ;
17286 bool result;
17287 PyObject * obj0 = 0 ;
17288 PyObject * obj1 = 0 ;
17289 char *kwnames[] = {
17290 (char *) "self",(char *) "but", NULL
17291 };
17292
17293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17295 if (SWIG_arg_fail(1)) SWIG_fail;
17296 if (obj1) {
17297 {
17298 arg2 = static_cast<int >(SWIG_As_int(obj1));
17299 if (SWIG_arg_fail(2)) SWIG_fail;
17300 }
17301 }
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17305
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 {
17310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17311 }
17312 return resultobj;
17313 fail:
17314 return NULL;
17315 }
17316
17317
17318 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17319 PyObject *resultobj = NULL;
17320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17321 int arg2 ;
17322 bool result;
17323 PyObject * obj0 = 0 ;
17324 PyObject * obj1 = 0 ;
17325 char *kwnames[] = {
17326 (char *) "self",(char *) "button", NULL
17327 };
17328
17329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17331 if (SWIG_arg_fail(1)) SWIG_fail;
17332 {
17333 arg2 = static_cast<int >(SWIG_As_int(obj1));
17334 if (SWIG_arg_fail(2)) SWIG_fail;
17335 }
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17339
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 {
17344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17345 }
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj = NULL;
17354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17355 int arg2 ;
17356 bool result;
17357 PyObject * obj0 = 0 ;
17358 PyObject * obj1 = 0 ;
17359 char *kwnames[] = {
17360 (char *) "self",(char *) "but", NULL
17361 };
17362
17363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17365 if (SWIG_arg_fail(1)) SWIG_fail;
17366 {
17367 arg2 = static_cast<int >(SWIG_As_int(obj1));
17368 if (SWIG_arg_fail(2)) SWIG_fail;
17369 }
17370 {
17371 PyThreadState* __tstate = wxPyBeginAllowThreads();
17372 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17373
17374 wxPyEndAllowThreads(__tstate);
17375 if (PyErr_Occurred()) SWIG_fail;
17376 }
17377 {
17378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17379 }
17380 return resultobj;
17381 fail:
17382 return NULL;
17383 }
17384
17385
17386 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17387 PyObject *resultobj = NULL;
17388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17389 int result;
17390 PyObject * obj0 = 0 ;
17391 char *kwnames[] = {
17392 (char *) "self", NULL
17393 };
17394
17395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17397 if (SWIG_arg_fail(1)) SWIG_fail;
17398 {
17399 PyThreadState* __tstate = wxPyBeginAllowThreads();
17400 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17401
17402 wxPyEndAllowThreads(__tstate);
17403 if (PyErr_Occurred()) SWIG_fail;
17404 }
17405 {
17406 resultobj = SWIG_From_int(static_cast<int >(result));
17407 }
17408 return resultobj;
17409 fail:
17410 return NULL;
17411 }
17412
17413
17414 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17415 PyObject *resultobj = NULL;
17416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17417 bool result;
17418 PyObject * obj0 = 0 ;
17419 char *kwnames[] = {
17420 (char *) "self", NULL
17421 };
17422
17423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17425 if (SWIG_arg_fail(1)) SWIG_fail;
17426 {
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17429
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 {
17434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17435 }
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = NULL;
17444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17445 bool result;
17446 PyObject * obj0 = 0 ;
17447 char *kwnames[] = {
17448 (char *) "self", NULL
17449 };
17450
17451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17453 if (SWIG_arg_fail(1)) SWIG_fail;
17454 {
17455 PyThreadState* __tstate = wxPyBeginAllowThreads();
17456 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17457
17458 wxPyEndAllowThreads(__tstate);
17459 if (PyErr_Occurred()) SWIG_fail;
17460 }
17461 {
17462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17463 }
17464 return resultobj;
17465 fail:
17466 return NULL;
17467 }
17468
17469
17470 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17471 PyObject *resultobj = NULL;
17472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17473 bool result;
17474 PyObject * obj0 = 0 ;
17475 char *kwnames[] = {
17476 (char *) "self", NULL
17477 };
17478
17479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17481 if (SWIG_arg_fail(1)) SWIG_fail;
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17485
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 {
17490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17491 }
17492 return resultobj;
17493 fail:
17494 return NULL;
17495 }
17496
17497
17498 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = NULL;
17500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17501 bool result;
17502 PyObject * obj0 = 0 ;
17503 char *kwnames[] = {
17504 (char *) "self", NULL
17505 };
17506
17507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17509 if (SWIG_arg_fail(1)) SWIG_fail;
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17513
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 {
17518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17519 }
17520 return resultobj;
17521 fail:
17522 return NULL;
17523 }
17524
17525
17526 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17527 PyObject *resultobj = NULL;
17528 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17529 bool result;
17530 PyObject * obj0 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17541
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 {
17546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17547 }
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj = NULL;
17556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17557 bool result;
17558 PyObject * obj0 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17569
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 {
17574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17575 }
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj = NULL;
17584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17585 bool result;
17586 PyObject * obj0 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17597
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj = NULL;
17612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17613 bool result;
17614 PyObject * obj0 = 0 ;
17615 char *kwnames[] = {
17616 (char *) "self", NULL
17617 };
17618
17619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17621 if (SWIG_arg_fail(1)) SWIG_fail;
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17625
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = NULL;
17640 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17641 bool result;
17642 PyObject * obj0 = 0 ;
17643 char *kwnames[] = {
17644 (char *) "self", NULL
17645 };
17646
17647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17649 if (SWIG_arg_fail(1)) SWIG_fail;
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17653
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17667 PyObject *resultobj = NULL;
17668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17669 bool result;
17670 PyObject * obj0 = 0 ;
17671 char *kwnames[] = {
17672 (char *) "self", NULL
17673 };
17674
17675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17677 if (SWIG_arg_fail(1)) SWIG_fail;
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17681
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 {
17686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17687 }
17688 return resultobj;
17689 fail:
17690 return NULL;
17691 }
17692
17693
17694 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17695 PyObject *resultobj = NULL;
17696 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17697 bool result;
17698 PyObject * obj0 = 0 ;
17699 char *kwnames[] = {
17700 (char *) "self", NULL
17701 };
17702
17703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17705 if (SWIG_arg_fail(1)) SWIG_fail;
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17709
17710 wxPyEndAllowThreads(__tstate);
17711 if (PyErr_Occurred()) SWIG_fail;
17712 }
17713 {
17714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17715 }
17716 return resultobj;
17717 fail:
17718 return NULL;
17719 }
17720
17721
17722 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17723 PyObject *resultobj = NULL;
17724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17725 bool result;
17726 PyObject * obj0 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 PyThreadState* __tstate = wxPyBeginAllowThreads();
17736 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17737
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17743 }
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj = NULL;
17752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17753 bool result;
17754 PyObject * obj0 = 0 ;
17755 char *kwnames[] = {
17756 (char *) "self", NULL
17757 };
17758
17759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17761 if (SWIG_arg_fail(1)) SWIG_fail;
17762 {
17763 PyThreadState* __tstate = wxPyBeginAllowThreads();
17764 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17765
17766 wxPyEndAllowThreads(__tstate);
17767 if (PyErr_Occurred()) SWIG_fail;
17768 }
17769 {
17770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17771 }
17772 return resultobj;
17773 fail:
17774 return NULL;
17775 }
17776
17777
17778 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj = NULL;
17780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17781 bool result;
17782 PyObject * obj0 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17793
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17799 }
17800 return resultobj;
17801 fail:
17802 return NULL;
17803 }
17804
17805
17806 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17807 PyObject *resultobj = NULL;
17808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17809 bool result;
17810 PyObject * obj0 = 0 ;
17811 char *kwnames[] = {
17812 (char *) "self", NULL
17813 };
17814
17815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17817 if (SWIG_arg_fail(1)) SWIG_fail;
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (bool)(arg1)->LeftIsDown();
17821
17822 wxPyEndAllowThreads(__tstate);
17823 if (PyErr_Occurred()) SWIG_fail;
17824 }
17825 {
17826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17827 }
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj = NULL;
17836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17837 bool result;
17838 PyObject * obj0 = 0 ;
17839 char *kwnames[] = {
17840 (char *) "self", NULL
17841 };
17842
17843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->MiddleIsDown();
17849
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17855 }
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj = NULL;
17864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17865 bool result;
17866 PyObject * obj0 = 0 ;
17867 char *kwnames[] = {
17868 (char *) "self", NULL
17869 };
17870
17871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17873 if (SWIG_arg_fail(1)) SWIG_fail;
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 result = (bool)(arg1)->RightIsDown();
17877
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 {
17882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj = NULL;
17892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17893 bool result;
17894 PyObject * obj0 = 0 ;
17895 char *kwnames[] = {
17896 (char *) "self", NULL
17897 };
17898
17899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17901 if (SWIG_arg_fail(1)) SWIG_fail;
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17905
17906 wxPyEndAllowThreads(__tstate);
17907 if (PyErr_Occurred()) SWIG_fail;
17908 }
17909 {
17910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17911 }
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17919 PyObject *resultobj = NULL;
17920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17921 bool result;
17922 PyObject * obj0 = 0 ;
17923 char *kwnames[] = {
17924 (char *) "self", NULL
17925 };
17926
17927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17929 if (SWIG_arg_fail(1)) SWIG_fail;
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 {
17938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17939 }
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj = NULL;
17948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17949 bool result;
17950 PyObject * obj0 = 0 ;
17951 char *kwnames[] = {
17952 (char *) "self", NULL
17953 };
17954
17955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 {
17959 PyThreadState* __tstate = wxPyBeginAllowThreads();
17960 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17961
17962 wxPyEndAllowThreads(__tstate);
17963 if (PyErr_Occurred()) SWIG_fail;
17964 }
17965 {
17966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17967 }
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj = NULL;
17976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17977 bool result;
17978 PyObject * obj0 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self", NULL
17981 };
17982
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17989
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 {
17994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17995 }
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj = NULL;
18004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18005 wxPoint result;
18006 PyObject * obj0 = 0 ;
18007 char *kwnames[] = {
18008 (char *) "self", NULL
18009 };
18010
18011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18013 if (SWIG_arg_fail(1)) SWIG_fail;
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (arg1)->GetPosition();
18017
18018 wxPyEndAllowThreads(__tstate);
18019 if (PyErr_Occurred()) SWIG_fail;
18020 }
18021 {
18022 wxPoint * resultptr;
18023 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = NULL;
18034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18035 long *arg2 = (long *) 0 ;
18036 long *arg3 = (long *) 0 ;
18037 long temp2 ;
18038 int res2 = 0 ;
18039 long temp3 ;
18040 int res3 = 0 ;
18041 PyObject * obj0 = 0 ;
18042 char *kwnames[] = {
18043 (char *) "self", NULL
18044 };
18045
18046 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18047 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18050 if (SWIG_arg_fail(1)) SWIG_fail;
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 (arg1)->GetPosition(arg2,arg3);
18054
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 Py_INCREF(Py_None); resultobj = Py_None;
18059 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18060 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18061 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18062 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = NULL;
18071 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18072 wxDC *arg2 = 0 ;
18073 wxPoint result;
18074 PyObject * obj0 = 0 ;
18075 PyObject * obj1 = 0 ;
18076 char *kwnames[] = {
18077 (char *) "self",(char *) "dc", NULL
18078 };
18079
18080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18082 if (SWIG_arg_fail(1)) SWIG_fail;
18083 {
18084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18085 if (SWIG_arg_fail(2)) SWIG_fail;
18086 if (arg2 == NULL) {
18087 SWIG_null_ref("wxDC");
18088 }
18089 if (SWIG_arg_fail(2)) SWIG_fail;
18090 }
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18094
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 {
18099 wxPoint * resultptr;
18100 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj = NULL;
18111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18112 int result;
18113 PyObject * obj0 = 0 ;
18114 char *kwnames[] = {
18115 (char *) "self", NULL
18116 };
18117
18118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18120 if (SWIG_arg_fail(1)) SWIG_fail;
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (int)((wxMouseEvent const *)arg1)->GetX();
18124
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 {
18129 resultobj = SWIG_From_int(static_cast<int >(result));
18130 }
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18138 PyObject *resultobj = NULL;
18139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18140 int result;
18141 PyObject * obj0 = 0 ;
18142 char *kwnames[] = {
18143 (char *) "self", NULL
18144 };
18145
18146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(1)) SWIG_fail;
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 result = (int)((wxMouseEvent const *)arg1)->GetY();
18152
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 {
18157 resultobj = SWIG_From_int(static_cast<int >(result));
18158 }
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj = NULL;
18167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18168 int result;
18169 PyObject * obj0 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 {
18185 resultobj = SWIG_From_int(static_cast<int >(result));
18186 }
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18194 PyObject *resultobj = NULL;
18195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18196 int result;
18197 PyObject * obj0 = 0 ;
18198 char *kwnames[] = {
18199 (char *) "self", NULL
18200 };
18201
18202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18204 if (SWIG_arg_fail(1)) SWIG_fail;
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18208
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 {
18213 resultobj = SWIG_From_int(static_cast<int >(result));
18214 }
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18222 PyObject *resultobj = NULL;
18223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18224 int result;
18225 PyObject * obj0 = 0 ;
18226 char *kwnames[] = {
18227 (char *) "self", NULL
18228 };
18229
18230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18232 if (SWIG_arg_fail(1)) SWIG_fail;
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 {
18241 resultobj = SWIG_From_int(static_cast<int >(result));
18242 }
18243 return resultobj;
18244 fail:
18245 return NULL;
18246 }
18247
18248
18249 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18250 PyObject *resultobj = NULL;
18251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18252 bool result;
18253 PyObject * obj0 = 0 ;
18254 char *kwnames[] = {
18255 (char *) "self", NULL
18256 };
18257
18258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18260 if (SWIG_arg_fail(1)) SWIG_fail;
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18264
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 {
18269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18270 }
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj = NULL;
18279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18280 int arg2 ;
18281 PyObject * obj0 = 0 ;
18282 PyObject * obj1 = 0 ;
18283 char *kwnames[] = {
18284 (char *) "self",(char *) "m_x", NULL
18285 };
18286
18287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18289 if (SWIG_arg_fail(1)) SWIG_fail;
18290 {
18291 arg2 = static_cast<int >(SWIG_As_int(obj1));
18292 if (SWIG_arg_fail(2)) SWIG_fail;
18293 }
18294 if (arg1) (arg1)->m_x = arg2;
18295
18296 Py_INCREF(Py_None); resultobj = Py_None;
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj = NULL;
18305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18306 int result;
18307 PyObject * obj0 = 0 ;
18308 char *kwnames[] = {
18309 (char *) "self", NULL
18310 };
18311
18312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18314 if (SWIG_arg_fail(1)) SWIG_fail;
18315 result = (int) ((arg1)->m_x);
18316
18317 {
18318 resultobj = SWIG_From_int(static_cast<int >(result));
18319 }
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj = NULL;
18328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18329 int arg2 ;
18330 PyObject * obj0 = 0 ;
18331 PyObject * obj1 = 0 ;
18332 char *kwnames[] = {
18333 (char *) "self",(char *) "m_y", NULL
18334 };
18335
18336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18338 if (SWIG_arg_fail(1)) SWIG_fail;
18339 {
18340 arg2 = static_cast<int >(SWIG_As_int(obj1));
18341 if (SWIG_arg_fail(2)) SWIG_fail;
18342 }
18343 if (arg1) (arg1)->m_y = arg2;
18344
18345 Py_INCREF(Py_None); resultobj = Py_None;
18346 return resultobj;
18347 fail:
18348 return NULL;
18349 }
18350
18351
18352 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18353 PyObject *resultobj = NULL;
18354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18355 int result;
18356 PyObject * obj0 = 0 ;
18357 char *kwnames[] = {
18358 (char *) "self", NULL
18359 };
18360
18361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18363 if (SWIG_arg_fail(1)) SWIG_fail;
18364 result = (int) ((arg1)->m_y);
18365
18366 {
18367 resultobj = SWIG_From_int(static_cast<int >(result));
18368 }
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj = NULL;
18377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18378 bool arg2 ;
18379 PyObject * obj0 = 0 ;
18380 PyObject * obj1 = 0 ;
18381 char *kwnames[] = {
18382 (char *) "self",(char *) "m_leftDown", NULL
18383 };
18384
18385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18387 if (SWIG_arg_fail(1)) SWIG_fail;
18388 {
18389 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18390 if (SWIG_arg_fail(2)) SWIG_fail;
18391 }
18392 if (arg1) (arg1)->m_leftDown = arg2;
18393
18394 Py_INCREF(Py_None); resultobj = Py_None;
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18402 PyObject *resultobj = NULL;
18403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18404 bool result;
18405 PyObject * obj0 = 0 ;
18406 char *kwnames[] = {
18407 (char *) "self", NULL
18408 };
18409
18410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18412 if (SWIG_arg_fail(1)) SWIG_fail;
18413 result = (bool) ((arg1)->m_leftDown);
18414
18415 {
18416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18417 }
18418 return resultobj;
18419 fail:
18420 return NULL;
18421 }
18422
18423
18424 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18425 PyObject *resultobj = NULL;
18426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18427 bool arg2 ;
18428 PyObject * obj0 = 0 ;
18429 PyObject * obj1 = 0 ;
18430 char *kwnames[] = {
18431 (char *) "self",(char *) "m_middleDown", NULL
18432 };
18433
18434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18436 if (SWIG_arg_fail(1)) SWIG_fail;
18437 {
18438 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18439 if (SWIG_arg_fail(2)) SWIG_fail;
18440 }
18441 if (arg1) (arg1)->m_middleDown = arg2;
18442
18443 Py_INCREF(Py_None); resultobj = Py_None;
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18451 PyObject *resultobj = NULL;
18452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18453 bool result;
18454 PyObject * obj0 = 0 ;
18455 char *kwnames[] = {
18456 (char *) "self", NULL
18457 };
18458
18459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18461 if (SWIG_arg_fail(1)) SWIG_fail;
18462 result = (bool) ((arg1)->m_middleDown);
18463
18464 {
18465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18466 }
18467 return resultobj;
18468 fail:
18469 return NULL;
18470 }
18471
18472
18473 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18474 PyObject *resultobj = NULL;
18475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18476 bool arg2 ;
18477 PyObject * obj0 = 0 ;
18478 PyObject * obj1 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self",(char *) "m_rightDown", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18488 if (SWIG_arg_fail(2)) SWIG_fail;
18489 }
18490 if (arg1) (arg1)->m_rightDown = arg2;
18491
18492 Py_INCREF(Py_None); resultobj = Py_None;
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18500 PyObject *resultobj = NULL;
18501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18502 bool result;
18503 PyObject * obj0 = 0 ;
18504 char *kwnames[] = {
18505 (char *) "self", NULL
18506 };
18507
18508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18510 if (SWIG_arg_fail(1)) SWIG_fail;
18511 result = (bool) ((arg1)->m_rightDown);
18512
18513 {
18514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18515 }
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj = NULL;
18524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18525 bool arg2 ;
18526 PyObject * obj0 = 0 ;
18527 PyObject * obj1 = 0 ;
18528 char *kwnames[] = {
18529 (char *) "self",(char *) "m_controlDown", NULL
18530 };
18531
18532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18534 if (SWIG_arg_fail(1)) SWIG_fail;
18535 {
18536 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18537 if (SWIG_arg_fail(2)) SWIG_fail;
18538 }
18539 if (arg1) (arg1)->m_controlDown = arg2;
18540
18541 Py_INCREF(Py_None); resultobj = Py_None;
18542 return resultobj;
18543 fail:
18544 return NULL;
18545 }
18546
18547
18548 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18549 PyObject *resultobj = NULL;
18550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18551 bool result;
18552 PyObject * obj0 = 0 ;
18553 char *kwnames[] = {
18554 (char *) "self", NULL
18555 };
18556
18557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18559 if (SWIG_arg_fail(1)) SWIG_fail;
18560 result = (bool) ((arg1)->m_controlDown);
18561
18562 {
18563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18564 }
18565 return resultobj;
18566 fail:
18567 return NULL;
18568 }
18569
18570
18571 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18572 PyObject *resultobj = NULL;
18573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18574 bool arg2 ;
18575 PyObject * obj0 = 0 ;
18576 PyObject * obj1 = 0 ;
18577 char *kwnames[] = {
18578 (char *) "self",(char *) "m_shiftDown", NULL
18579 };
18580
18581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18583 if (SWIG_arg_fail(1)) SWIG_fail;
18584 {
18585 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18586 if (SWIG_arg_fail(2)) SWIG_fail;
18587 }
18588 if (arg1) (arg1)->m_shiftDown = arg2;
18589
18590 Py_INCREF(Py_None); resultobj = Py_None;
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj = NULL;
18599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18600 bool result;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 result = (bool) ((arg1)->m_shiftDown);
18610
18611 {
18612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18613 }
18614 return resultobj;
18615 fail:
18616 return NULL;
18617 }
18618
18619
18620 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18621 PyObject *resultobj = NULL;
18622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18623 bool arg2 ;
18624 PyObject * obj0 = 0 ;
18625 PyObject * obj1 = 0 ;
18626 char *kwnames[] = {
18627 (char *) "self",(char *) "m_altDown", NULL
18628 };
18629
18630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18632 if (SWIG_arg_fail(1)) SWIG_fail;
18633 {
18634 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18635 if (SWIG_arg_fail(2)) SWIG_fail;
18636 }
18637 if (arg1) (arg1)->m_altDown = arg2;
18638
18639 Py_INCREF(Py_None); resultobj = Py_None;
18640 return resultobj;
18641 fail:
18642 return NULL;
18643 }
18644
18645
18646 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18647 PyObject *resultobj = NULL;
18648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18649 bool result;
18650 PyObject * obj0 = 0 ;
18651 char *kwnames[] = {
18652 (char *) "self", NULL
18653 };
18654
18655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18657 if (SWIG_arg_fail(1)) SWIG_fail;
18658 result = (bool) ((arg1)->m_altDown);
18659
18660 {
18661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18662 }
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18670 PyObject *resultobj = NULL;
18671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18672 bool arg2 ;
18673 PyObject * obj0 = 0 ;
18674 PyObject * obj1 = 0 ;
18675 char *kwnames[] = {
18676 (char *) "self",(char *) "m_metaDown", NULL
18677 };
18678
18679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18681 if (SWIG_arg_fail(1)) SWIG_fail;
18682 {
18683 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18684 if (SWIG_arg_fail(2)) SWIG_fail;
18685 }
18686 if (arg1) (arg1)->m_metaDown = arg2;
18687
18688 Py_INCREF(Py_None); resultobj = Py_None;
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj = NULL;
18697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18698 bool result;
18699 PyObject * obj0 = 0 ;
18700 char *kwnames[] = {
18701 (char *) "self", NULL
18702 };
18703
18704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18706 if (SWIG_arg_fail(1)) SWIG_fail;
18707 result = (bool) ((arg1)->m_metaDown);
18708
18709 {
18710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18711 }
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18719 PyObject *resultobj = NULL;
18720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18721 int arg2 ;
18722 PyObject * obj0 = 0 ;
18723 PyObject * obj1 = 0 ;
18724 char *kwnames[] = {
18725 (char *) "self",(char *) "m_wheelRotation", NULL
18726 };
18727
18728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18730 if (SWIG_arg_fail(1)) SWIG_fail;
18731 {
18732 arg2 = static_cast<int >(SWIG_As_int(obj1));
18733 if (SWIG_arg_fail(2)) SWIG_fail;
18734 }
18735 if (arg1) (arg1)->m_wheelRotation = arg2;
18736
18737 Py_INCREF(Py_None); resultobj = Py_None;
18738 return resultobj;
18739 fail:
18740 return NULL;
18741 }
18742
18743
18744 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18745 PyObject *resultobj = NULL;
18746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18747 int result;
18748 PyObject * obj0 = 0 ;
18749 char *kwnames[] = {
18750 (char *) "self", NULL
18751 };
18752
18753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18755 if (SWIG_arg_fail(1)) SWIG_fail;
18756 result = (int) ((arg1)->m_wheelRotation);
18757
18758 {
18759 resultobj = SWIG_From_int(static_cast<int >(result));
18760 }
18761 return resultobj;
18762 fail:
18763 return NULL;
18764 }
18765
18766
18767 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18768 PyObject *resultobj = NULL;
18769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18770 int arg2 ;
18771 PyObject * obj0 = 0 ;
18772 PyObject * obj1 = 0 ;
18773 char *kwnames[] = {
18774 (char *) "self",(char *) "m_wheelDelta", NULL
18775 };
18776
18777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18779 if (SWIG_arg_fail(1)) SWIG_fail;
18780 {
18781 arg2 = static_cast<int >(SWIG_As_int(obj1));
18782 if (SWIG_arg_fail(2)) SWIG_fail;
18783 }
18784 if (arg1) (arg1)->m_wheelDelta = arg2;
18785
18786 Py_INCREF(Py_None); resultobj = Py_None;
18787 return resultobj;
18788 fail:
18789 return NULL;
18790 }
18791
18792
18793 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18794 PyObject *resultobj = NULL;
18795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18796 int result;
18797 PyObject * obj0 = 0 ;
18798 char *kwnames[] = {
18799 (char *) "self", NULL
18800 };
18801
18802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18804 if (SWIG_arg_fail(1)) SWIG_fail;
18805 result = (int) ((arg1)->m_wheelDelta);
18806
18807 {
18808 resultobj = SWIG_From_int(static_cast<int >(result));
18809 }
18810 return resultobj;
18811 fail:
18812 return NULL;
18813 }
18814
18815
18816 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18817 PyObject *resultobj = NULL;
18818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18819 int arg2 ;
18820 PyObject * obj0 = 0 ;
18821 PyObject * obj1 = 0 ;
18822 char *kwnames[] = {
18823 (char *) "self",(char *) "m_linesPerAction", NULL
18824 };
18825
18826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18828 if (SWIG_arg_fail(1)) SWIG_fail;
18829 {
18830 arg2 = static_cast<int >(SWIG_As_int(obj1));
18831 if (SWIG_arg_fail(2)) SWIG_fail;
18832 }
18833 if (arg1) (arg1)->m_linesPerAction = arg2;
18834
18835 Py_INCREF(Py_None); resultobj = Py_None;
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = NULL;
18844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18845 int result;
18846 PyObject * obj0 = 0 ;
18847 char *kwnames[] = {
18848 (char *) "self", NULL
18849 };
18850
18851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18853 if (SWIG_arg_fail(1)) SWIG_fail;
18854 result = (int) ((arg1)->m_linesPerAction);
18855
18856 {
18857 resultobj = SWIG_From_int(static_cast<int >(result));
18858 }
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18866 PyObject *obj;
18867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18868 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18869 Py_INCREF(obj);
18870 return Py_BuildValue((char *)"");
18871 }
18872 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj = NULL;
18874 int arg1 = (int) 0 ;
18875 int arg2 = (int) 0 ;
18876 wxSetCursorEvent *result;
18877 PyObject * obj0 = 0 ;
18878 PyObject * obj1 = 0 ;
18879 char *kwnames[] = {
18880 (char *) "x",(char *) "y", NULL
18881 };
18882
18883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18884 if (obj0) {
18885 {
18886 arg1 = static_cast<int >(SWIG_As_int(obj0));
18887 if (SWIG_arg_fail(1)) SWIG_fail;
18888 }
18889 }
18890 if (obj1) {
18891 {
18892 arg2 = static_cast<int >(SWIG_As_int(obj1));
18893 if (SWIG_arg_fail(2)) SWIG_fail;
18894 }
18895 }
18896 {
18897 PyThreadState* __tstate = wxPyBeginAllowThreads();
18898 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18899
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = NULL;
18912 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18913 int result;
18914 PyObject * obj0 = 0 ;
18915 char *kwnames[] = {
18916 (char *) "self", NULL
18917 };
18918
18919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18921 if (SWIG_arg_fail(1)) SWIG_fail;
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18925
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 {
18930 resultobj = SWIG_From_int(static_cast<int >(result));
18931 }
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18939 PyObject *resultobj = NULL;
18940 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18941 int result;
18942 PyObject * obj0 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "self", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 {
18951 PyThreadState* __tstate = wxPyBeginAllowThreads();
18952 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18953
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 {
18958 resultobj = SWIG_From_int(static_cast<int >(result));
18959 }
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18967 PyObject *resultobj = NULL;
18968 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18969 wxCursor *arg2 = 0 ;
18970 PyObject * obj0 = 0 ;
18971 PyObject * obj1 = 0 ;
18972 char *kwnames[] = {
18973 (char *) "self",(char *) "cursor", NULL
18974 };
18975
18976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18978 if (SWIG_arg_fail(1)) SWIG_fail;
18979 {
18980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(2)) SWIG_fail;
18982 if (arg2 == NULL) {
18983 SWIG_null_ref("wxCursor");
18984 }
18985 if (SWIG_arg_fail(2)) SWIG_fail;
18986 }
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 (arg1)->SetCursor((wxCursor const &)*arg2);
18990
18991 wxPyEndAllowThreads(__tstate);
18992 if (PyErr_Occurred()) SWIG_fail;
18993 }
18994 Py_INCREF(Py_None); resultobj = Py_None;
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj = NULL;
19003 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19004 wxCursor *result;
19005 PyObject * obj0 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "self", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 {
19016 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19017 result = (wxCursor *) &_result_ref;
19018 }
19019
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 {
19024 wxCursor* resultptr = new wxCursor(*result);
19025 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19026 }
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19034 PyObject *resultobj = NULL;
19035 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19036 bool result;
19037 PyObject * obj0 = 0 ;
19038 char *kwnames[] = {
19039 (char *) "self", NULL
19040 };
19041
19042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19044 if (SWIG_arg_fail(1)) SWIG_fail;
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19048
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 {
19053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19054 }
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19062 PyObject *obj;
19063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19064 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19065 Py_INCREF(obj);
19066 return Py_BuildValue((char *)"");
19067 }
19068 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj = NULL;
19070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19071 wxKeyEvent *result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "eventType", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19078 if (obj0) {
19079 {
19080 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19081 if (SWIG_arg_fail(1)) SWIG_fail;
19082 }
19083 }
19084 {
19085 PyThreadState* __tstate = wxPyBeginAllowThreads();
19086 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19087
19088 wxPyEndAllowThreads(__tstate);
19089 if (PyErr_Occurred()) SWIG_fail;
19090 }
19091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = NULL;
19100 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19101 bool result;
19102 PyObject * obj0 = 0 ;
19103 char *kwnames[] = {
19104 (char *) "self", NULL
19105 };
19106
19107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19109 if (SWIG_arg_fail(1)) SWIG_fail;
19110 {
19111 PyThreadState* __tstate = wxPyBeginAllowThreads();
19112 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19113
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 {
19118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19119 }
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19127 PyObject *resultobj = NULL;
19128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19129 bool result;
19130 PyObject * obj0 = 0 ;
19131 char *kwnames[] = {
19132 (char *) "self", NULL
19133 };
19134
19135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19137 if (SWIG_arg_fail(1)) SWIG_fail;
19138 {
19139 PyThreadState* __tstate = wxPyBeginAllowThreads();
19140 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19141
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 {
19146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19147 }
19148 return resultobj;
19149 fail:
19150 return NULL;
19151 }
19152
19153
19154 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19155 PyObject *resultobj = NULL;
19156 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19157 bool result;
19158 PyObject * obj0 = 0 ;
19159 char *kwnames[] = {
19160 (char *) "self", NULL
19161 };
19162
19163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19165 if (SWIG_arg_fail(1)) SWIG_fail;
19166 {
19167 PyThreadState* __tstate = wxPyBeginAllowThreads();
19168 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19169
19170 wxPyEndAllowThreads(__tstate);
19171 if (PyErr_Occurred()) SWIG_fail;
19172 }
19173 {
19174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19175 }
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj = NULL;
19184 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19185 bool result;
19186 PyObject * obj0 = 0 ;
19187 char *kwnames[] = {
19188 (char *) "self", NULL
19189 };
19190
19191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(1)) SWIG_fail;
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19197
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 {
19202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19203 }
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj = NULL;
19212 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19213 bool result;
19214 PyObject * obj0 = 0 ;
19215 char *kwnames[] = {
19216 (char *) "self", NULL
19217 };
19218
19219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19221 if (SWIG_arg_fail(1)) SWIG_fail;
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 {
19230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj = NULL;
19240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19241 bool result;
19242 PyObject * obj0 = 0 ;
19243 char *kwnames[] = {
19244 (char *) "self", NULL
19245 };
19246
19247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19249 if (SWIG_arg_fail(1)) SWIG_fail;
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19253
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj = NULL;
19268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19269 int result;
19270 PyObject * obj0 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "self", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19277 if (SWIG_arg_fail(1)) SWIG_fail;
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19281
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = SWIG_From_int(static_cast<int >(result));
19287 }
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19295 PyObject *resultobj = NULL;
19296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19297 int result;
19298 PyObject * obj0 = 0 ;
19299 char *kwnames[] = {
19300 (char *) "self", NULL
19301 };
19302
19303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19305 if (SWIG_arg_fail(1)) SWIG_fail;
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19309
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 {
19314 resultobj = SWIG_From_int(static_cast<int >(result));
19315 }
19316 return resultobj;
19317 fail:
19318 return NULL;
19319 }
19320
19321
19322 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19323 PyObject *resultobj = NULL;
19324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19325 unsigned int result;
19326 PyObject * obj0 = 0 ;
19327 char *kwnames[] = {
19328 (char *) "self", NULL
19329 };
19330
19331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19333 if (SWIG_arg_fail(1)) SWIG_fail;
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19337
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 {
19342 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19343 }
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19351 PyObject *resultobj = NULL;
19352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19353 unsigned int result;
19354 PyObject * obj0 = 0 ;
19355 char *kwnames[] = {
19356 (char *) "self", NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19361 if (SWIG_arg_fail(1)) SWIG_fail;
19362 {
19363 PyThreadState* __tstate = wxPyBeginAllowThreads();
19364 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19365
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 {
19370 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19371 }
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj = NULL;
19380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19381 wxPoint result;
19382 PyObject * obj0 = 0 ;
19383 char *kwnames[] = {
19384 (char *) "self", NULL
19385 };
19386
19387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19389 if (SWIG_arg_fail(1)) SWIG_fail;
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = (arg1)->GetPosition();
19393
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 {
19398 wxPoint * resultptr;
19399 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19409 PyObject *resultobj = NULL;
19410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19411 long *arg2 = (long *) 0 ;
19412 long *arg3 = (long *) 0 ;
19413 long temp2 ;
19414 int res2 = 0 ;
19415 long temp3 ;
19416 int res3 = 0 ;
19417 PyObject * obj0 = 0 ;
19418 char *kwnames[] = {
19419 (char *) "self", NULL
19420 };
19421
19422 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19423 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19426 if (SWIG_arg_fail(1)) SWIG_fail;
19427 {
19428 PyThreadState* __tstate = wxPyBeginAllowThreads();
19429 (arg1)->GetPosition(arg2,arg3);
19430
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 Py_INCREF(Py_None); resultobj = Py_None;
19435 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19436 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19437 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19438 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj = NULL;
19447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19448 int result;
19449 PyObject * obj0 = 0 ;
19450 char *kwnames[] = {
19451 (char *) "self", NULL
19452 };
19453
19454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19456 if (SWIG_arg_fail(1)) SWIG_fail;
19457 {
19458 PyThreadState* __tstate = wxPyBeginAllowThreads();
19459 result = (int)((wxKeyEvent const *)arg1)->GetX();
19460
19461 wxPyEndAllowThreads(__tstate);
19462 if (PyErr_Occurred()) SWIG_fail;
19463 }
19464 {
19465 resultobj = SWIG_From_int(static_cast<int >(result));
19466 }
19467 return resultobj;
19468 fail:
19469 return NULL;
19470 }
19471
19472
19473 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19474 PyObject *resultobj = NULL;
19475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19476 int result;
19477 PyObject * obj0 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "self", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19484 if (SWIG_arg_fail(1)) SWIG_fail;
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = (int)((wxKeyEvent const *)arg1)->GetY();
19488
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 {
19493 resultobj = SWIG_From_int(static_cast<int >(result));
19494 }
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19502 PyObject *resultobj = NULL;
19503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19504 int arg2 ;
19505 PyObject * obj0 = 0 ;
19506 PyObject * obj1 = 0 ;
19507 char *kwnames[] = {
19508 (char *) "self",(char *) "m_x", NULL
19509 };
19510
19511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19513 if (SWIG_arg_fail(1)) SWIG_fail;
19514 {
19515 arg2 = static_cast<int >(SWIG_As_int(obj1));
19516 if (SWIG_arg_fail(2)) SWIG_fail;
19517 }
19518 if (arg1) (arg1)->m_x = arg2;
19519
19520 Py_INCREF(Py_None); resultobj = Py_None;
19521 return resultobj;
19522 fail:
19523 return NULL;
19524 }
19525
19526
19527 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj = NULL;
19529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19530 int result;
19531 PyObject * obj0 = 0 ;
19532 char *kwnames[] = {
19533 (char *) "self", NULL
19534 };
19535
19536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19538 if (SWIG_arg_fail(1)) SWIG_fail;
19539 result = (int) ((arg1)->m_x);
19540
19541 {
19542 resultobj = SWIG_From_int(static_cast<int >(result));
19543 }
19544 return resultobj;
19545 fail:
19546 return NULL;
19547 }
19548
19549
19550 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19551 PyObject *resultobj = NULL;
19552 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19553 int arg2 ;
19554 PyObject * obj0 = 0 ;
19555 PyObject * obj1 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "self",(char *) "m_y", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 {
19564 arg2 = static_cast<int >(SWIG_As_int(obj1));
19565 if (SWIG_arg_fail(2)) SWIG_fail;
19566 }
19567 if (arg1) (arg1)->m_y = arg2;
19568
19569 Py_INCREF(Py_None); resultobj = Py_None;
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19577 PyObject *resultobj = NULL;
19578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19579 int result;
19580 PyObject * obj0 = 0 ;
19581 char *kwnames[] = {
19582 (char *) "self", NULL
19583 };
19584
19585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19587 if (SWIG_arg_fail(1)) SWIG_fail;
19588 result = (int) ((arg1)->m_y);
19589
19590 {
19591 resultobj = SWIG_From_int(static_cast<int >(result));
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj = NULL;
19601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19602 long arg2 ;
19603 PyObject * obj0 = 0 ;
19604 PyObject * obj1 = 0 ;
19605 char *kwnames[] = {
19606 (char *) "self",(char *) "m_keyCode", NULL
19607 };
19608
19609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19611 if (SWIG_arg_fail(1)) SWIG_fail;
19612 {
19613 arg2 = static_cast<long >(SWIG_As_long(obj1));
19614 if (SWIG_arg_fail(2)) SWIG_fail;
19615 }
19616 if (arg1) (arg1)->m_keyCode = arg2;
19617
19618 Py_INCREF(Py_None); resultobj = Py_None;
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = NULL;
19627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19628 long result;
19629 PyObject * obj0 = 0 ;
19630 char *kwnames[] = {
19631 (char *) "self", NULL
19632 };
19633
19634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19636 if (SWIG_arg_fail(1)) SWIG_fail;
19637 result = (long) ((arg1)->m_keyCode);
19638
19639 {
19640 resultobj = SWIG_From_long(static_cast<long >(result));
19641 }
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj = NULL;
19650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19651 bool arg2 ;
19652 PyObject * obj0 = 0 ;
19653 PyObject * obj1 = 0 ;
19654 char *kwnames[] = {
19655 (char *) "self",(char *) "m_controlDown", NULL
19656 };
19657
19658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19660 if (SWIG_arg_fail(1)) SWIG_fail;
19661 {
19662 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19663 if (SWIG_arg_fail(2)) SWIG_fail;
19664 }
19665 if (arg1) (arg1)->m_controlDown = arg2;
19666
19667 Py_INCREF(Py_None); resultobj = Py_None;
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj = NULL;
19676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19677 bool result;
19678 PyObject * obj0 = 0 ;
19679 char *kwnames[] = {
19680 (char *) "self", NULL
19681 };
19682
19683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19685 if (SWIG_arg_fail(1)) SWIG_fail;
19686 result = (bool) ((arg1)->m_controlDown);
19687
19688 {
19689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19690 }
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19698 PyObject *resultobj = NULL;
19699 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19700 bool arg2 ;
19701 PyObject * obj0 = 0 ;
19702 PyObject * obj1 = 0 ;
19703 char *kwnames[] = {
19704 (char *) "self",(char *) "m_shiftDown", NULL
19705 };
19706
19707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19709 if (SWIG_arg_fail(1)) SWIG_fail;
19710 {
19711 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19712 if (SWIG_arg_fail(2)) SWIG_fail;
19713 }
19714 if (arg1) (arg1)->m_shiftDown = arg2;
19715
19716 Py_INCREF(Py_None); resultobj = Py_None;
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj = NULL;
19725 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19726 bool result;
19727 PyObject * obj0 = 0 ;
19728 char *kwnames[] = {
19729 (char *) "self", NULL
19730 };
19731
19732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19734 if (SWIG_arg_fail(1)) SWIG_fail;
19735 result = (bool) ((arg1)->m_shiftDown);
19736
19737 {
19738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19739 }
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj = NULL;
19748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19749 bool arg2 ;
19750 PyObject * obj0 = 0 ;
19751 PyObject * obj1 = 0 ;
19752 char *kwnames[] = {
19753 (char *) "self",(char *) "m_altDown", NULL
19754 };
19755
19756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19758 if (SWIG_arg_fail(1)) SWIG_fail;
19759 {
19760 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19761 if (SWIG_arg_fail(2)) SWIG_fail;
19762 }
19763 if (arg1) (arg1)->m_altDown = arg2;
19764
19765 Py_INCREF(Py_None); resultobj = Py_None;
19766 return resultobj;
19767 fail:
19768 return NULL;
19769 }
19770
19771
19772 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19773 PyObject *resultobj = NULL;
19774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19775 bool result;
19776 PyObject * obj0 = 0 ;
19777 char *kwnames[] = {
19778 (char *) "self", NULL
19779 };
19780
19781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19783 if (SWIG_arg_fail(1)) SWIG_fail;
19784 result = (bool) ((arg1)->m_altDown);
19785
19786 {
19787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19788 }
19789 return resultobj;
19790 fail:
19791 return NULL;
19792 }
19793
19794
19795 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19796 PyObject *resultobj = NULL;
19797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19798 bool arg2 ;
19799 PyObject * obj0 = 0 ;
19800 PyObject * obj1 = 0 ;
19801 char *kwnames[] = {
19802 (char *) "self",(char *) "m_metaDown", NULL
19803 };
19804
19805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19807 if (SWIG_arg_fail(1)) SWIG_fail;
19808 {
19809 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19810 if (SWIG_arg_fail(2)) SWIG_fail;
19811 }
19812 if (arg1) (arg1)->m_metaDown = arg2;
19813
19814 Py_INCREF(Py_None); resultobj = Py_None;
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj = NULL;
19823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19824 bool result;
19825 PyObject * obj0 = 0 ;
19826 char *kwnames[] = {
19827 (char *) "self", NULL
19828 };
19829
19830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19832 if (SWIG_arg_fail(1)) SWIG_fail;
19833 result = (bool) ((arg1)->m_metaDown);
19834
19835 {
19836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19837 }
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19845 PyObject *resultobj = NULL;
19846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19847 bool arg2 ;
19848 PyObject * obj0 = 0 ;
19849 PyObject * obj1 = 0 ;
19850 char *kwnames[] = {
19851 (char *) "self",(char *) "m_scanCode", NULL
19852 };
19853
19854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19856 if (SWIG_arg_fail(1)) SWIG_fail;
19857 {
19858 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19859 if (SWIG_arg_fail(2)) SWIG_fail;
19860 }
19861 if (arg1) (arg1)->m_scanCode = arg2;
19862
19863 Py_INCREF(Py_None); resultobj = Py_None;
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj = NULL;
19872 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19873 bool result;
19874 PyObject * obj0 = 0 ;
19875 char *kwnames[] = {
19876 (char *) "self", NULL
19877 };
19878
19879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19881 if (SWIG_arg_fail(1)) SWIG_fail;
19882 result = (bool) ((arg1)->m_scanCode);
19883
19884 {
19885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19886 }
19887 return resultobj;
19888 fail:
19889 return NULL;
19890 }
19891
19892
19893 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19894 PyObject *resultobj = NULL;
19895 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19896 unsigned int arg2 ;
19897 PyObject * obj0 = 0 ;
19898 PyObject * obj1 = 0 ;
19899 char *kwnames[] = {
19900 (char *) "self",(char *) "m_rawCode", NULL
19901 };
19902
19903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19905 if (SWIG_arg_fail(1)) SWIG_fail;
19906 {
19907 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19908 if (SWIG_arg_fail(2)) SWIG_fail;
19909 }
19910 if (arg1) (arg1)->m_rawCode = arg2;
19911
19912 Py_INCREF(Py_None); resultobj = Py_None;
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19920 PyObject *resultobj = NULL;
19921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19922 unsigned int result;
19923 PyObject * obj0 = 0 ;
19924 char *kwnames[] = {
19925 (char *) "self", NULL
19926 };
19927
19928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19930 if (SWIG_arg_fail(1)) SWIG_fail;
19931 result = (unsigned int) ((arg1)->m_rawCode);
19932
19933 {
19934 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19935 }
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19943 PyObject *resultobj = NULL;
19944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19945 unsigned int arg2 ;
19946 PyObject * obj0 = 0 ;
19947 PyObject * obj1 = 0 ;
19948 char *kwnames[] = {
19949 (char *) "self",(char *) "m_rawFlags", NULL
19950 };
19951
19952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19954 if (SWIG_arg_fail(1)) SWIG_fail;
19955 {
19956 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19957 if (SWIG_arg_fail(2)) SWIG_fail;
19958 }
19959 if (arg1) (arg1)->m_rawFlags = arg2;
19960
19961 Py_INCREF(Py_None); resultobj = Py_None;
19962 return resultobj;
19963 fail:
19964 return NULL;
19965 }
19966
19967
19968 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj = NULL;
19970 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19971 unsigned int result;
19972 PyObject * obj0 = 0 ;
19973 char *kwnames[] = {
19974 (char *) "self", NULL
19975 };
19976
19977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19979 if (SWIG_arg_fail(1)) SWIG_fail;
19980 result = (unsigned int) ((arg1)->m_rawFlags);
19981
19982 {
19983 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19984 }
19985 return resultobj;
19986 fail:
19987 return NULL;
19988 }
19989
19990
19991 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19992 PyObject *obj;
19993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19994 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19995 Py_INCREF(obj);
19996 return Py_BuildValue((char *)"");
19997 }
19998 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj = NULL;
20000 wxSize const &arg1_defvalue = wxDefaultSize ;
20001 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20002 int arg2 = (int) 0 ;
20003 wxSizeEvent *result;
20004 wxSize temp1 ;
20005 PyObject * obj0 = 0 ;
20006 PyObject * obj1 = 0 ;
20007 char *kwnames[] = {
20008 (char *) "sz",(char *) "winid", NULL
20009 };
20010
20011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20012 if (obj0) {
20013 {
20014 arg1 = &temp1;
20015 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20016 }
20017 }
20018 if (obj1) {
20019 {
20020 arg2 = static_cast<int >(SWIG_As_int(obj1));
20021 if (SWIG_arg_fail(2)) SWIG_fail;
20022 }
20023 }
20024 {
20025 PyThreadState* __tstate = wxPyBeginAllowThreads();
20026 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20027
20028 wxPyEndAllowThreads(__tstate);
20029 if (PyErr_Occurred()) SWIG_fail;
20030 }
20031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20032 return resultobj;
20033 fail:
20034 return NULL;
20035 }
20036
20037
20038 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20039 PyObject *resultobj = NULL;
20040 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20041 wxSize result;
20042 PyObject * obj0 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "self", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20049 if (SWIG_arg_fail(1)) SWIG_fail;
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = ((wxSizeEvent const *)arg1)->GetSize();
20053
20054 wxPyEndAllowThreads(__tstate);
20055 if (PyErr_Occurred()) SWIG_fail;
20056 }
20057 {
20058 wxSize * resultptr;
20059 resultptr = new wxSize(static_cast<wxSize & >(result));
20060 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20061 }
20062 return resultobj;
20063 fail:
20064 return NULL;
20065 }
20066
20067
20068 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20069 PyObject *resultobj = NULL;
20070 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20071 wxRect result;
20072 PyObject * obj0 = 0 ;
20073 char *kwnames[] = {
20074 (char *) "self", NULL
20075 };
20076
20077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20079 if (SWIG_arg_fail(1)) SWIG_fail;
20080 {
20081 PyThreadState* __tstate = wxPyBeginAllowThreads();
20082 result = ((wxSizeEvent const *)arg1)->GetRect();
20083
20084 wxPyEndAllowThreads(__tstate);
20085 if (PyErr_Occurred()) SWIG_fail;
20086 }
20087 {
20088 wxRect * resultptr;
20089 resultptr = new wxRect(static_cast<wxRect & >(result));
20090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20091 }
20092 return resultobj;
20093 fail:
20094 return NULL;
20095 }
20096
20097
20098 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20099 PyObject *resultobj = NULL;
20100 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20101 wxRect arg2 ;
20102 PyObject * obj0 = 0 ;
20103 PyObject * obj1 = 0 ;
20104 char *kwnames[] = {
20105 (char *) "self",(char *) "rect", NULL
20106 };
20107
20108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20110 if (SWIG_arg_fail(1)) SWIG_fail;
20111 {
20112 wxRect * argp;
20113 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20114 if (SWIG_arg_fail(2)) SWIG_fail;
20115 if (argp == NULL) {
20116 SWIG_null_ref("wxRect");
20117 }
20118 if (SWIG_arg_fail(2)) SWIG_fail;
20119 arg2 = *argp;
20120 }
20121 {
20122 PyThreadState* __tstate = wxPyBeginAllowThreads();
20123 (arg1)->SetRect(arg2);
20124
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 Py_INCREF(Py_None); resultobj = Py_None;
20129 return resultobj;
20130 fail:
20131 return NULL;
20132 }
20133
20134
20135 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20136 PyObject *resultobj = NULL;
20137 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20138 wxSize arg2 ;
20139 PyObject * obj0 = 0 ;
20140 PyObject * obj1 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "self",(char *) "size", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20147 if (SWIG_arg_fail(1)) SWIG_fail;
20148 {
20149 wxSize * argp;
20150 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20151 if (SWIG_arg_fail(2)) SWIG_fail;
20152 if (argp == NULL) {
20153 SWIG_null_ref("wxSize");
20154 }
20155 if (SWIG_arg_fail(2)) SWIG_fail;
20156 arg2 = *argp;
20157 }
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 wxSizeEvent_SetSize(arg1,arg2);
20161
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 Py_INCREF(Py_None); resultobj = Py_None;
20166 return resultobj;
20167 fail:
20168 return NULL;
20169 }
20170
20171
20172 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20173 PyObject *resultobj = NULL;
20174 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20175 wxSize *arg2 = (wxSize *) 0 ;
20176 PyObject * obj0 = 0 ;
20177 PyObject * obj1 = 0 ;
20178 char *kwnames[] = {
20179 (char *) "self",(char *) "m_size", NULL
20180 };
20181
20182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20184 if (SWIG_arg_fail(1)) SWIG_fail;
20185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20186 if (SWIG_arg_fail(2)) SWIG_fail;
20187 if (arg1) (arg1)->m_size = *arg2;
20188
20189 Py_INCREF(Py_None); resultobj = Py_None;
20190 return resultobj;
20191 fail:
20192 return NULL;
20193 }
20194
20195
20196 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj = NULL;
20198 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20199 wxSize *result;
20200 PyObject * obj0 = 0 ;
20201 char *kwnames[] = {
20202 (char *) "self", NULL
20203 };
20204
20205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20207 if (SWIG_arg_fail(1)) SWIG_fail;
20208 result = (wxSize *)& ((arg1)->m_size);
20209
20210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj = NULL;
20219 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20220 wxRect *arg2 = (wxRect *) 0 ;
20221 PyObject * obj0 = 0 ;
20222 PyObject * obj1 = 0 ;
20223 char *kwnames[] = {
20224 (char *) "self",(char *) "m_rect", NULL
20225 };
20226
20227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20229 if (SWIG_arg_fail(1)) SWIG_fail;
20230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20231 if (SWIG_arg_fail(2)) SWIG_fail;
20232 if (arg1) (arg1)->m_rect = *arg2;
20233
20234 Py_INCREF(Py_None); resultobj = Py_None;
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj = NULL;
20243 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20244 wxRect *result;
20245 PyObject * obj0 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 result = (wxRect *)& ((arg1)->m_rect);
20254
20255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20263 PyObject *obj;
20264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20265 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20266 Py_INCREF(obj);
20267 return Py_BuildValue((char *)"");
20268 }
20269 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj = NULL;
20271 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20272 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20273 int arg2 = (int) 0 ;
20274 wxMoveEvent *result;
20275 wxPoint temp1 ;
20276 PyObject * obj0 = 0 ;
20277 PyObject * obj1 = 0 ;
20278 char *kwnames[] = {
20279 (char *) "pos",(char *) "winid", NULL
20280 };
20281
20282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20283 if (obj0) {
20284 {
20285 arg1 = &temp1;
20286 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20287 }
20288 }
20289 if (obj1) {
20290 {
20291 arg2 = static_cast<int >(SWIG_As_int(obj1));
20292 if (SWIG_arg_fail(2)) SWIG_fail;
20293 }
20294 }
20295 {
20296 PyThreadState* __tstate = wxPyBeginAllowThreads();
20297 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20298
20299 wxPyEndAllowThreads(__tstate);
20300 if (PyErr_Occurred()) SWIG_fail;
20301 }
20302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj = NULL;
20311 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20312 wxPoint result;
20313 PyObject * obj0 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "self", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20320 if (SWIG_arg_fail(1)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = ((wxMoveEvent const *)arg1)->GetPosition();
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 wxPoint * resultptr;
20330 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20332 }
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj = NULL;
20341 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20342 wxRect result;
20343 PyObject * obj0 = 0 ;
20344 char *kwnames[] = {
20345 (char *) "self", NULL
20346 };
20347
20348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20350 if (SWIG_arg_fail(1)) SWIG_fail;
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = ((wxMoveEvent const *)arg1)->GetRect();
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 wxRect * resultptr;
20360 resultptr = new wxRect(static_cast<wxRect & >(result));
20361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20362 }
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj = NULL;
20371 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20372 wxRect *arg2 = 0 ;
20373 wxRect temp2 ;
20374 PyObject * obj0 = 0 ;
20375 PyObject * obj1 = 0 ;
20376 char *kwnames[] = {
20377 (char *) "self",(char *) "rect", NULL
20378 };
20379
20380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20382 if (SWIG_arg_fail(1)) SWIG_fail;
20383 {
20384 arg2 = &temp2;
20385 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20386 }
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 (arg1)->SetRect((wxRect const &)*arg2);
20390
20391 wxPyEndAllowThreads(__tstate);
20392 if (PyErr_Occurred()) SWIG_fail;
20393 }
20394 Py_INCREF(Py_None); resultobj = Py_None;
20395 return resultobj;
20396 fail:
20397 return NULL;
20398 }
20399
20400
20401 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20402 PyObject *resultobj = NULL;
20403 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20404 wxPoint *arg2 = 0 ;
20405 wxPoint temp2 ;
20406 PyObject * obj0 = 0 ;
20407 PyObject * obj1 = 0 ;
20408 char *kwnames[] = {
20409 (char *) "self",(char *) "pos", NULL
20410 };
20411
20412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20414 if (SWIG_arg_fail(1)) SWIG_fail;
20415 {
20416 arg2 = &temp2;
20417 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20418 }
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 (arg1)->SetPosition((wxPoint const &)*arg2);
20422
20423 wxPyEndAllowThreads(__tstate);
20424 if (PyErr_Occurred()) SWIG_fail;
20425 }
20426 Py_INCREF(Py_None); resultobj = Py_None;
20427 return resultobj;
20428 fail:
20429 return NULL;
20430 }
20431
20432
20433 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20434 PyObject *obj;
20435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20436 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20437 Py_INCREF(obj);
20438 return Py_BuildValue((char *)"");
20439 }
20440 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj = NULL;
20442 int arg1 = (int) 0 ;
20443 wxPaintEvent *result;
20444 PyObject * obj0 = 0 ;
20445 char *kwnames[] = {
20446 (char *) "Id", NULL
20447 };
20448
20449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20450 if (obj0) {
20451 {
20452 arg1 = static_cast<int >(SWIG_As_int(obj0));
20453 if (SWIG_arg_fail(1)) SWIG_fail;
20454 }
20455 }
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20471 PyObject *obj;
20472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20473 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20474 Py_INCREF(obj);
20475 return Py_BuildValue((char *)"");
20476 }
20477 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20478 PyObject *resultobj = NULL;
20479 int arg1 = (int) 0 ;
20480 wxNcPaintEvent *result;
20481 PyObject * obj0 = 0 ;
20482 char *kwnames[] = {
20483 (char *) "winid", NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20487 if (obj0) {
20488 {
20489 arg1 = static_cast<int >(SWIG_As_int(obj0));
20490 if (SWIG_arg_fail(1)) SWIG_fail;
20491 }
20492 }
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20496
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20508 PyObject *obj;
20509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20510 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20511 Py_INCREF(obj);
20512 return Py_BuildValue((char *)"");
20513 }
20514 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20515 PyObject *resultobj = NULL;
20516 int arg1 = (int) 0 ;
20517 wxDC *arg2 = (wxDC *) NULL ;
20518 wxEraseEvent *result;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 char *kwnames[] = {
20522 (char *) "Id",(char *) "dc", NULL
20523 };
20524
20525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20526 if (obj0) {
20527 {
20528 arg1 = static_cast<int >(SWIG_As_int(obj0));
20529 if (SWIG_arg_fail(1)) SWIG_fail;
20530 }
20531 }
20532 if (obj1) {
20533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20534 if (SWIG_arg_fail(2)) SWIG_fail;
20535 }
20536 {
20537 PyThreadState* __tstate = wxPyBeginAllowThreads();
20538 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20539
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20544 return resultobj;
20545 fail:
20546 return NULL;
20547 }
20548
20549
20550 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20551 PyObject *resultobj = NULL;
20552 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20553 wxDC *result;
20554 PyObject * obj0 = 0 ;
20555 char *kwnames[] = {
20556 (char *) "self", NULL
20557 };
20558
20559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20561 if (SWIG_arg_fail(1)) SWIG_fail;
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20565
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 {
20570 resultobj = wxPyMake_wxObject(result, 0);
20571 }
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20579 PyObject *obj;
20580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20581 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20582 Py_INCREF(obj);
20583 return Py_BuildValue((char *)"");
20584 }
20585 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20586 PyObject *resultobj = NULL;
20587 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20588 int arg2 = (int) 0 ;
20589 wxFocusEvent *result;
20590 PyObject * obj0 = 0 ;
20591 PyObject * obj1 = 0 ;
20592 char *kwnames[] = {
20593 (char *) "type",(char *) "winid", NULL
20594 };
20595
20596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20597 if (obj0) {
20598 {
20599 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20600 if (SWIG_arg_fail(1)) SWIG_fail;
20601 }
20602 }
20603 if (obj1) {
20604 {
20605 arg2 = static_cast<int >(SWIG_As_int(obj1));
20606 if (SWIG_arg_fail(2)) SWIG_fail;
20607 }
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20624 PyObject *resultobj = NULL;
20625 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20626 wxWindow *result;
20627 PyObject * obj0 = 0 ;
20628 char *kwnames[] = {
20629 (char *) "self", NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20634 if (SWIG_arg_fail(1)) SWIG_fail;
20635 {
20636 PyThreadState* __tstate = wxPyBeginAllowThreads();
20637 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20638
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 {
20643 resultobj = wxPyMake_wxObject(result, 0);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj = NULL;
20653 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20654 wxWindow *arg2 = (wxWindow *) 0 ;
20655 PyObject * obj0 = 0 ;
20656 PyObject * obj1 = 0 ;
20657 char *kwnames[] = {
20658 (char *) "self",(char *) "win", NULL
20659 };
20660
20661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20663 if (SWIG_arg_fail(1)) SWIG_fail;
20664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20665 if (SWIG_arg_fail(2)) SWIG_fail;
20666 {
20667 PyThreadState* __tstate = wxPyBeginAllowThreads();
20668 (arg1)->SetWindow(arg2);
20669
20670 wxPyEndAllowThreads(__tstate);
20671 if (PyErr_Occurred()) SWIG_fail;
20672 }
20673 Py_INCREF(Py_None); resultobj = Py_None;
20674 return resultobj;
20675 fail:
20676 return NULL;
20677 }
20678
20679
20680 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20681 PyObject *obj;
20682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20683 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20684 Py_INCREF(obj);
20685 return Py_BuildValue((char *)"");
20686 }
20687 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20688 PyObject *resultobj = NULL;
20689 wxWindow *arg1 = (wxWindow *) NULL ;
20690 wxChildFocusEvent *result;
20691 PyObject * obj0 = 0 ;
20692 char *kwnames[] = {
20693 (char *) "win", NULL
20694 };
20695
20696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20697 if (obj0) {
20698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 }
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20704
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj = NULL;
20717 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20718 wxWindow *result;
20719 PyObject * obj0 = 0 ;
20720 char *kwnames[] = {
20721 (char *) "self", NULL
20722 };
20723
20724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20726 if (SWIG_arg_fail(1)) SWIG_fail;
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20730
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 {
20735 resultobj = wxPyMake_wxObject(result, 0);
20736 }
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20744 PyObject *obj;
20745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20746 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20747 Py_INCREF(obj);
20748 return Py_BuildValue((char *)"");
20749 }
20750 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj = NULL;
20752 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20753 bool arg2 = (bool) true ;
20754 int arg3 = (int) 0 ;
20755 wxActivateEvent *result;
20756 PyObject * obj0 = 0 ;
20757 PyObject * obj1 = 0 ;
20758 PyObject * obj2 = 0 ;
20759 char *kwnames[] = {
20760 (char *) "type",(char *) "active",(char *) "Id", NULL
20761 };
20762
20763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20764 if (obj0) {
20765 {
20766 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20767 if (SWIG_arg_fail(1)) SWIG_fail;
20768 }
20769 }
20770 if (obj1) {
20771 {
20772 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20773 if (SWIG_arg_fail(2)) SWIG_fail;
20774 }
20775 }
20776 if (obj2) {
20777 {
20778 arg3 = static_cast<int >(SWIG_As_int(obj2));
20779 if (SWIG_arg_fail(3)) SWIG_fail;
20780 }
20781 }
20782 {
20783 PyThreadState* __tstate = wxPyBeginAllowThreads();
20784 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20785
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20790 return resultobj;
20791 fail:
20792 return NULL;
20793 }
20794
20795
20796 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20797 PyObject *resultobj = NULL;
20798 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20799 bool result;
20800 PyObject * obj0 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "self", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20807 if (SWIG_arg_fail(1)) SWIG_fail;
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20811
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 {
20816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20817 }
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20825 PyObject *obj;
20826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20827 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20828 Py_INCREF(obj);
20829 return Py_BuildValue((char *)"");
20830 }
20831 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20832 PyObject *resultobj = NULL;
20833 int arg1 = (int) 0 ;
20834 wxInitDialogEvent *result;
20835 PyObject * obj0 = 0 ;
20836 char *kwnames[] = {
20837 (char *) "Id", NULL
20838 };
20839
20840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20841 if (obj0) {
20842 {
20843 arg1 = static_cast<int >(SWIG_As_int(obj0));
20844 if (SWIG_arg_fail(1)) SWIG_fail;
20845 }
20846 }
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20850
20851 wxPyEndAllowThreads(__tstate);
20852 if (PyErr_Occurred()) SWIG_fail;
20853 }
20854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20855 return resultobj;
20856 fail:
20857 return NULL;
20858 }
20859
20860
20861 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20862 PyObject *obj;
20863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20864 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20865 Py_INCREF(obj);
20866 return Py_BuildValue((char *)"");
20867 }
20868 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20869 PyObject *resultobj = NULL;
20870 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20871 int arg2 = (int) 0 ;
20872 wxMenu *arg3 = (wxMenu *) NULL ;
20873 wxMenuEvent *result;
20874 PyObject * obj0 = 0 ;
20875 PyObject * obj1 = 0 ;
20876 PyObject * obj2 = 0 ;
20877 char *kwnames[] = {
20878 (char *) "type",(char *) "winid",(char *) "menu", NULL
20879 };
20880
20881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20882 if (obj0) {
20883 {
20884 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20885 if (SWIG_arg_fail(1)) SWIG_fail;
20886 }
20887 }
20888 if (obj1) {
20889 {
20890 arg2 = static_cast<int >(SWIG_As_int(obj1));
20891 if (SWIG_arg_fail(2)) SWIG_fail;
20892 }
20893 }
20894 if (obj2) {
20895 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20896 if (SWIG_arg_fail(3)) SWIG_fail;
20897 }
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20901
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20913 PyObject *resultobj = NULL;
20914 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20915 int result;
20916 PyObject * obj0 = 0 ;
20917 char *kwnames[] = {
20918 (char *) "self", NULL
20919 };
20920
20921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20923 if (SWIG_arg_fail(1)) SWIG_fail;
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20927
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 {
20932 resultobj = SWIG_From_int(static_cast<int >(result));
20933 }
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj = NULL;
20942 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20943 bool result;
20944 PyObject * obj0 = 0 ;
20945 char *kwnames[] = {
20946 (char *) "self", NULL
20947 };
20948
20949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20951 if (SWIG_arg_fail(1)) SWIG_fail;
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20955
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 {
20960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20961 }
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj = NULL;
20970 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20971 wxMenu *result;
20972 PyObject * obj0 = 0 ;
20973 char *kwnames[] = {
20974 (char *) "self", NULL
20975 };
20976
20977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(1)) SWIG_fail;
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 {
20988 resultobj = wxPyMake_wxObject(result, 0);
20989 }
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20997 PyObject *obj;
20998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20999 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21000 Py_INCREF(obj);
21001 return Py_BuildValue((char *)"");
21002 }
21003 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21004 PyObject *resultobj = NULL;
21005 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21006 int arg2 = (int) 0 ;
21007 wxCloseEvent *result;
21008 PyObject * obj0 = 0 ;
21009 PyObject * obj1 = 0 ;
21010 char *kwnames[] = {
21011 (char *) "type",(char *) "winid", NULL
21012 };
21013
21014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21015 if (obj0) {
21016 {
21017 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21018 if (SWIG_arg_fail(1)) SWIG_fail;
21019 }
21020 }
21021 if (obj1) {
21022 {
21023 arg2 = static_cast<int >(SWIG_As_int(obj1));
21024 if (SWIG_arg_fail(2)) SWIG_fail;
21025 }
21026 }
21027 {
21028 PyThreadState* __tstate = wxPyBeginAllowThreads();
21029 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21030
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21035 return resultobj;
21036 fail:
21037 return NULL;
21038 }
21039
21040
21041 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21042 PyObject *resultobj = NULL;
21043 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21044 bool arg2 ;
21045 PyObject * obj0 = 0 ;
21046 PyObject * obj1 = 0 ;
21047 char *kwnames[] = {
21048 (char *) "self",(char *) "logOff", NULL
21049 };
21050
21051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21053 if (SWIG_arg_fail(1)) SWIG_fail;
21054 {
21055 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21056 if (SWIG_arg_fail(2)) SWIG_fail;
21057 }
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 (arg1)->SetLoggingOff(arg2);
21061
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 Py_INCREF(Py_None); resultobj = Py_None;
21066 return resultobj;
21067 fail:
21068 return NULL;
21069 }
21070
21071
21072 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21073 PyObject *resultobj = NULL;
21074 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21075 bool result;
21076 PyObject * obj0 = 0 ;
21077 char *kwnames[] = {
21078 (char *) "self", NULL
21079 };
21080
21081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21083 if (SWIG_arg_fail(1)) SWIG_fail;
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21087
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 {
21092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21093 }
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21101 PyObject *resultobj = NULL;
21102 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21103 bool arg2 = (bool) true ;
21104 PyObject * obj0 = 0 ;
21105 PyObject * obj1 = 0 ;
21106 char *kwnames[] = {
21107 (char *) "self",(char *) "veto", NULL
21108 };
21109
21110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 if (obj1) {
21114 {
21115 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21116 if (SWIG_arg_fail(2)) SWIG_fail;
21117 }
21118 }
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 (arg1)->Veto(arg2);
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 Py_INCREF(Py_None); resultobj = Py_None;
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21134 PyObject *resultobj = NULL;
21135 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21136 bool result;
21137 PyObject * obj0 = 0 ;
21138 char *kwnames[] = {
21139 (char *) "self", NULL
21140 };
21141
21142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21144 if (SWIG_arg_fail(1)) SWIG_fail;
21145 {
21146 PyThreadState* __tstate = wxPyBeginAllowThreads();
21147 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21148
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 {
21153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21154 }
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21162 PyObject *resultobj = NULL;
21163 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21164 bool arg2 ;
21165 PyObject * obj0 = 0 ;
21166 PyObject * obj1 = 0 ;
21167 char *kwnames[] = {
21168 (char *) "self",(char *) "canVeto", NULL
21169 };
21170
21171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21173 if (SWIG_arg_fail(1)) SWIG_fail;
21174 {
21175 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21176 if (SWIG_arg_fail(2)) SWIG_fail;
21177 }
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 (arg1)->SetCanVeto(arg2);
21181
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 Py_INCREF(Py_None); resultobj = Py_None;
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21193 PyObject *resultobj = NULL;
21194 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21195 bool result;
21196 PyObject * obj0 = 0 ;
21197 char *kwnames[] = {
21198 (char *) "self", NULL
21199 };
21200
21201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21203 if (SWIG_arg_fail(1)) SWIG_fail;
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21207
21208 wxPyEndAllowThreads(__tstate);
21209 if (PyErr_Occurred()) SWIG_fail;
21210 }
21211 {
21212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21213 }
21214 return resultobj;
21215 fail:
21216 return NULL;
21217 }
21218
21219
21220 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21221 PyObject *obj;
21222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21223 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21224 Py_INCREF(obj);
21225 return Py_BuildValue((char *)"");
21226 }
21227 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21228 PyObject *resultobj = NULL;
21229 int arg1 = (int) 0 ;
21230 bool arg2 = (bool) false ;
21231 wxShowEvent *result;
21232 PyObject * obj0 = 0 ;
21233 PyObject * obj1 = 0 ;
21234 char *kwnames[] = {
21235 (char *) "winid",(char *) "show", NULL
21236 };
21237
21238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21239 if (obj0) {
21240 {
21241 arg1 = static_cast<int >(SWIG_As_int(obj0));
21242 if (SWIG_arg_fail(1)) SWIG_fail;
21243 }
21244 }
21245 if (obj1) {
21246 {
21247 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21248 if (SWIG_arg_fail(2)) SWIG_fail;
21249 }
21250 }
21251 {
21252 PyThreadState* __tstate = wxPyBeginAllowThreads();
21253 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21254
21255 wxPyEndAllowThreads(__tstate);
21256 if (PyErr_Occurred()) SWIG_fail;
21257 }
21258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21266 PyObject *resultobj = NULL;
21267 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21268 bool arg2 ;
21269 PyObject * obj0 = 0 ;
21270 PyObject * obj1 = 0 ;
21271 char *kwnames[] = {
21272 (char *) "self",(char *) "show", NULL
21273 };
21274
21275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21277 if (SWIG_arg_fail(1)) SWIG_fail;
21278 {
21279 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21280 if (SWIG_arg_fail(2)) SWIG_fail;
21281 }
21282 {
21283 PyThreadState* __tstate = wxPyBeginAllowThreads();
21284 (arg1)->SetShow(arg2);
21285
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 Py_INCREF(Py_None); resultobj = Py_None;
21290 return resultobj;
21291 fail:
21292 return NULL;
21293 }
21294
21295
21296 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21297 PyObject *resultobj = NULL;
21298 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21299 bool result;
21300 PyObject * obj0 = 0 ;
21301 char *kwnames[] = {
21302 (char *) "self", NULL
21303 };
21304
21305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21307 if (SWIG_arg_fail(1)) SWIG_fail;
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21311
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 {
21316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21317 }
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21325 PyObject *obj;
21326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21327 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21328 Py_INCREF(obj);
21329 return Py_BuildValue((char *)"");
21330 }
21331 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21332 PyObject *resultobj = NULL;
21333 int arg1 = (int) 0 ;
21334 bool arg2 = (bool) true ;
21335 wxIconizeEvent *result;
21336 PyObject * obj0 = 0 ;
21337 PyObject * obj1 = 0 ;
21338 char *kwnames[] = {
21339 (char *) "id",(char *) "iconized", NULL
21340 };
21341
21342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21343 if (obj0) {
21344 {
21345 arg1 = static_cast<int >(SWIG_As_int(obj0));
21346 if (SWIG_arg_fail(1)) SWIG_fail;
21347 }
21348 }
21349 if (obj1) {
21350 {
21351 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21352 if (SWIG_arg_fail(2)) SWIG_fail;
21353 }
21354 }
21355 {
21356 PyThreadState* __tstate = wxPyBeginAllowThreads();
21357 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21358
21359 wxPyEndAllowThreads(__tstate);
21360 if (PyErr_Occurred()) SWIG_fail;
21361 }
21362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21363 return resultobj;
21364 fail:
21365 return NULL;
21366 }
21367
21368
21369 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21370 PyObject *resultobj = NULL;
21371 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21372 bool result;
21373 PyObject * obj0 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "self", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21380 if (SWIG_arg_fail(1)) SWIG_fail;
21381 {
21382 PyThreadState* __tstate = wxPyBeginAllowThreads();
21383 result = (bool)(arg1)->Iconized();
21384
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 {
21389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21398 PyObject *obj;
21399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21400 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21401 Py_INCREF(obj);
21402 return Py_BuildValue((char *)"");
21403 }
21404 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21405 PyObject *resultobj = NULL;
21406 int arg1 = (int) 0 ;
21407 wxMaximizeEvent *result;
21408 PyObject * obj0 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "id", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21414 if (obj0) {
21415 {
21416 arg1 = static_cast<int >(SWIG_As_int(obj0));
21417 if (SWIG_arg_fail(1)) SWIG_fail;
21418 }
21419 }
21420 {
21421 PyThreadState* __tstate = wxPyBeginAllowThreads();
21422 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21423
21424 wxPyEndAllowThreads(__tstate);
21425 if (PyErr_Occurred()) SWIG_fail;
21426 }
21427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21428 return resultobj;
21429 fail:
21430 return NULL;
21431 }
21432
21433
21434 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21435 PyObject *obj;
21436 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21437 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21438 Py_INCREF(obj);
21439 return Py_BuildValue((char *)"");
21440 }
21441 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21442 PyObject *resultobj = NULL;
21443 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21444 wxPoint result;
21445 PyObject * obj0 = 0 ;
21446 char *kwnames[] = {
21447 (char *) "self", NULL
21448 };
21449
21450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21452 if (SWIG_arg_fail(1)) SWIG_fail;
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (arg1)->GetPosition();
21456
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 {
21461 wxPoint * resultptr;
21462 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21464 }
21465 return resultobj;
21466 fail:
21467 return NULL;
21468 }
21469
21470
21471 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21472 PyObject *resultobj = NULL;
21473 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21474 int result;
21475 PyObject * obj0 = 0 ;
21476 char *kwnames[] = {
21477 (char *) "self", NULL
21478 };
21479
21480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21482 if (SWIG_arg_fail(1)) SWIG_fail;
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (int)(arg1)->GetNumberOfFiles();
21486
21487 wxPyEndAllowThreads(__tstate);
21488 if (PyErr_Occurred()) SWIG_fail;
21489 }
21490 {
21491 resultobj = SWIG_From_int(static_cast<int >(result));
21492 }
21493 return resultobj;
21494 fail:
21495 return NULL;
21496 }
21497
21498
21499 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21500 PyObject *resultobj = NULL;
21501 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21502 PyObject *result;
21503 PyObject * obj0 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21514
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 resultobj = result;
21519 return resultobj;
21520 fail:
21521 return NULL;
21522 }
21523
21524
21525 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21526 PyObject *obj;
21527 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21528 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21529 Py_INCREF(obj);
21530 return Py_BuildValue((char *)"");
21531 }
21532 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj = NULL;
21534 int arg1 = (int) 0 ;
21535 wxUpdateUIEvent *result;
21536 PyObject * obj0 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "commandId", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21542 if (obj0) {
21543 {
21544 arg1 = static_cast<int >(SWIG_As_int(obj0));
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 }
21547 }
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21551
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21556 return resultobj;
21557 fail:
21558 return NULL;
21559 }
21560
21561
21562 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21563 PyObject *resultobj = NULL;
21564 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21565 bool result;
21566 PyObject * obj0 = 0 ;
21567 char *kwnames[] = {
21568 (char *) "self", NULL
21569 };
21570
21571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21573 if (SWIG_arg_fail(1)) SWIG_fail;
21574 {
21575 PyThreadState* __tstate = wxPyBeginAllowThreads();
21576 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21577
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 {
21582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21583 }
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj = NULL;
21592 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21593 bool result;
21594 PyObject * obj0 = 0 ;
21595 char *kwnames[] = {
21596 (char *) "self", NULL
21597 };
21598
21599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21601 if (SWIG_arg_fail(1)) SWIG_fail;
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21605
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 {
21610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21611 }
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21619 PyObject *resultobj = NULL;
21620 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21621 wxString result;
21622 PyObject * obj0 = 0 ;
21623 char *kwnames[] = {
21624 (char *) "self", NULL
21625 };
21626
21627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21629 if (SWIG_arg_fail(1)) SWIG_fail;
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21633
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 {
21638 #if wxUSE_UNICODE
21639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21640 #else
21641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21642 #endif
21643 }
21644 return resultobj;
21645 fail:
21646 return NULL;
21647 }
21648
21649
21650 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21651 PyObject *resultobj = NULL;
21652 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21653 bool result;
21654 PyObject * obj0 = 0 ;
21655 char *kwnames[] = {
21656 (char *) "self", NULL
21657 };
21658
21659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21661 if (SWIG_arg_fail(1)) SWIG_fail;
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21665
21666 wxPyEndAllowThreads(__tstate);
21667 if (PyErr_Occurred()) SWIG_fail;
21668 }
21669 {
21670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21671 }
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj = NULL;
21680 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21681 bool result;
21682 PyObject * obj0 = 0 ;
21683 char *kwnames[] = {
21684 (char *) "self", NULL
21685 };
21686
21687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21689 if (SWIG_arg_fail(1)) SWIG_fail;
21690 {
21691 PyThreadState* __tstate = wxPyBeginAllowThreads();
21692 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21693
21694 wxPyEndAllowThreads(__tstate);
21695 if (PyErr_Occurred()) SWIG_fail;
21696 }
21697 {
21698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21699 }
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj = NULL;
21708 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21709 bool result;
21710 PyObject * obj0 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj = NULL;
21736 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21737 bool arg2 ;
21738 PyObject * obj0 = 0 ;
21739 PyObject * obj1 = 0 ;
21740 char *kwnames[] = {
21741 (char *) "self",(char *) "check", NULL
21742 };
21743
21744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21746 if (SWIG_arg_fail(1)) SWIG_fail;
21747 {
21748 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21749 if (SWIG_arg_fail(2)) SWIG_fail;
21750 }
21751 {
21752 PyThreadState* __tstate = wxPyBeginAllowThreads();
21753 (arg1)->Check(arg2);
21754
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 Py_INCREF(Py_None); resultobj = Py_None;
21759 return resultobj;
21760 fail:
21761 return NULL;
21762 }
21763
21764
21765 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21766 PyObject *resultobj = NULL;
21767 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21768 bool arg2 ;
21769 PyObject * obj0 = 0 ;
21770 PyObject * obj1 = 0 ;
21771 char *kwnames[] = {
21772 (char *) "self",(char *) "enable", NULL
21773 };
21774
21775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21777 if (SWIG_arg_fail(1)) SWIG_fail;
21778 {
21779 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21780 if (SWIG_arg_fail(2)) SWIG_fail;
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 (arg1)->Enable(arg2);
21785
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 Py_INCREF(Py_None); resultobj = Py_None;
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21797 PyObject *resultobj = NULL;
21798 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21799 wxString *arg2 = 0 ;
21800 bool temp2 = false ;
21801 PyObject * obj0 = 0 ;
21802 PyObject * obj1 = 0 ;
21803 char *kwnames[] = {
21804 (char *) "self",(char *) "text", NULL
21805 };
21806
21807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21809 if (SWIG_arg_fail(1)) SWIG_fail;
21810 {
21811 arg2 = wxString_in_helper(obj1);
21812 if (arg2 == NULL) SWIG_fail;
21813 temp2 = true;
21814 }
21815 {
21816 PyThreadState* __tstate = wxPyBeginAllowThreads();
21817 (arg1)->SetText((wxString const &)*arg2);
21818
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 Py_INCREF(Py_None); resultobj = Py_None;
21823 {
21824 if (temp2)
21825 delete arg2;
21826 }
21827 return resultobj;
21828 fail:
21829 {
21830 if (temp2)
21831 delete arg2;
21832 }
21833 return NULL;
21834 }
21835
21836
21837 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21838 PyObject *resultobj = NULL;
21839 long arg1 ;
21840 PyObject * obj0 = 0 ;
21841 char *kwnames[] = {
21842 (char *) "updateInterval", NULL
21843 };
21844
21845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21846 {
21847 arg1 = static_cast<long >(SWIG_As_long(obj0));
21848 if (SWIG_arg_fail(1)) SWIG_fail;
21849 }
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 wxUpdateUIEvent::SetUpdateInterval(arg1);
21853
21854 wxPyEndAllowThreads(__tstate);
21855 if (PyErr_Occurred()) SWIG_fail;
21856 }
21857 Py_INCREF(Py_None); resultobj = Py_None;
21858 return resultobj;
21859 fail:
21860 return NULL;
21861 }
21862
21863
21864 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21865 PyObject *resultobj = NULL;
21866 long result;
21867 char *kwnames[] = {
21868 NULL
21869 };
21870
21871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21872 {
21873 PyThreadState* __tstate = wxPyBeginAllowThreads();
21874 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21875
21876 wxPyEndAllowThreads(__tstate);
21877 if (PyErr_Occurred()) SWIG_fail;
21878 }
21879 {
21880 resultobj = SWIG_From_long(static_cast<long >(result));
21881 }
21882 return resultobj;
21883 fail:
21884 return NULL;
21885 }
21886
21887
21888 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21889 PyObject *resultobj = NULL;
21890 wxWindow *arg1 = (wxWindow *) 0 ;
21891 bool result;
21892 PyObject * obj0 = 0 ;
21893 char *kwnames[] = {
21894 (char *) "win", NULL
21895 };
21896
21897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21899 if (SWIG_arg_fail(1)) SWIG_fail;
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj = NULL;
21918 char *kwnames[] = {
21919 NULL
21920 };
21921
21922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21923 {
21924 PyThreadState* __tstate = wxPyBeginAllowThreads();
21925 wxUpdateUIEvent::ResetUpdateTime();
21926
21927 wxPyEndAllowThreads(__tstate);
21928 if (PyErr_Occurred()) SWIG_fail;
21929 }
21930 Py_INCREF(Py_None); resultobj = Py_None;
21931 return resultobj;
21932 fail:
21933 return NULL;
21934 }
21935
21936
21937 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21938 PyObject *resultobj = NULL;
21939 wxUpdateUIMode arg1 ;
21940 PyObject * obj0 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "mode", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21946 {
21947 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
21948 if (SWIG_arg_fail(1)) SWIG_fail;
21949 }
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 wxUpdateUIEvent::SetMode(arg1);
21953
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 Py_INCREF(Py_None); resultobj = Py_None;
21958 return resultobj;
21959 fail:
21960 return NULL;
21961 }
21962
21963
21964 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21965 PyObject *resultobj = NULL;
21966 wxUpdateUIMode result;
21967 char *kwnames[] = {
21968 NULL
21969 };
21970
21971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21975
21976 wxPyEndAllowThreads(__tstate);
21977 if (PyErr_Occurred()) SWIG_fail;
21978 }
21979 resultobj = SWIG_From_int((result));
21980 return resultobj;
21981 fail:
21982 return NULL;
21983 }
21984
21985
21986 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21987 PyObject *obj;
21988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21989 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21990 Py_INCREF(obj);
21991 return Py_BuildValue((char *)"");
21992 }
21993 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21994 PyObject *resultobj = NULL;
21995 wxSysColourChangedEvent *result;
21996 char *kwnames[] = {
21997 NULL
21998 };
21999
22000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22016 PyObject *obj;
22017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22018 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22019 Py_INCREF(obj);
22020 return Py_BuildValue((char *)"");
22021 }
22022 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22023 PyObject *resultobj = NULL;
22024 int arg1 = (int) 0 ;
22025 wxWindow *arg2 = (wxWindow *) NULL ;
22026 wxMouseCaptureChangedEvent *result;
22027 PyObject * obj0 = 0 ;
22028 PyObject * obj1 = 0 ;
22029 char *kwnames[] = {
22030 (char *) "winid",(char *) "gainedCapture", NULL
22031 };
22032
22033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22034 if (obj0) {
22035 {
22036 arg1 = static_cast<int >(SWIG_As_int(obj0));
22037 if (SWIG_arg_fail(1)) SWIG_fail;
22038 }
22039 }
22040 if (obj1) {
22041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22042 if (SWIG_arg_fail(2)) SWIG_fail;
22043 }
22044 {
22045 PyThreadState* __tstate = wxPyBeginAllowThreads();
22046 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22047
22048 wxPyEndAllowThreads(__tstate);
22049 if (PyErr_Occurred()) SWIG_fail;
22050 }
22051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22059 PyObject *resultobj = NULL;
22060 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22061 wxWindow *result;
22062 PyObject * obj0 = 0 ;
22063 char *kwnames[] = {
22064 (char *) "self", NULL
22065 };
22066
22067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(1)) SWIG_fail;
22070 {
22071 PyThreadState* __tstate = wxPyBeginAllowThreads();
22072 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22073
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 {
22078 resultobj = wxPyMake_wxObject(result, 0);
22079 }
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22087 PyObject *obj;
22088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22089 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22090 Py_INCREF(obj);
22091 return Py_BuildValue((char *)"");
22092 }
22093 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22094 PyObject *resultobj = NULL;
22095 wxDisplayChangedEvent *result;
22096 char *kwnames[] = {
22097 NULL
22098 };
22099
22100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22104
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22109 return resultobj;
22110 fail:
22111 return NULL;
22112 }
22113
22114
22115 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22116 PyObject *obj;
22117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22118 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22119 Py_INCREF(obj);
22120 return Py_BuildValue((char *)"");
22121 }
22122 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj = NULL;
22124 int arg1 = (int) 0 ;
22125 wxPaletteChangedEvent *result;
22126 PyObject * obj0 = 0 ;
22127 char *kwnames[] = {
22128 (char *) "id", NULL
22129 };
22130
22131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22132 if (obj0) {
22133 {
22134 arg1 = static_cast<int >(SWIG_As_int(obj0));
22135 if (SWIG_arg_fail(1)) SWIG_fail;
22136 }
22137 }
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22141
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22146 return resultobj;
22147 fail:
22148 return NULL;
22149 }
22150
22151
22152 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22153 PyObject *resultobj = NULL;
22154 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22155 wxWindow *arg2 = (wxWindow *) 0 ;
22156 PyObject * obj0 = 0 ;
22157 PyObject * obj1 = 0 ;
22158 char *kwnames[] = {
22159 (char *) "self",(char *) "win", NULL
22160 };
22161
22162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22164 if (SWIG_arg_fail(1)) SWIG_fail;
22165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22166 if (SWIG_arg_fail(2)) SWIG_fail;
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 (arg1)->SetChangedWindow(arg2);
22170
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 Py_INCREF(Py_None); resultobj = Py_None;
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22182 PyObject *resultobj = NULL;
22183 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22184 wxWindow *result;
22185 PyObject * obj0 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "self", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22192 if (SWIG_arg_fail(1)) SWIG_fail;
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (wxWindow *)(arg1)->GetChangedWindow();
22196
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 {
22201 resultobj = wxPyMake_wxObject(result, 0);
22202 }
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22210 PyObject *obj;
22211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22212 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22213 Py_INCREF(obj);
22214 return Py_BuildValue((char *)"");
22215 }
22216 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = NULL;
22218 int arg1 = (int) 0 ;
22219 wxQueryNewPaletteEvent *result;
22220 PyObject * obj0 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "winid", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22226 if (obj0) {
22227 {
22228 arg1 = static_cast<int >(SWIG_As_int(obj0));
22229 if (SWIG_arg_fail(1)) SWIG_fail;
22230 }
22231 }
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22235
22236 wxPyEndAllowThreads(__tstate);
22237 if (PyErr_Occurred()) SWIG_fail;
22238 }
22239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22240 return resultobj;
22241 fail:
22242 return NULL;
22243 }
22244
22245
22246 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22247 PyObject *resultobj = NULL;
22248 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22249 bool arg2 ;
22250 PyObject * obj0 = 0 ;
22251 PyObject * obj1 = 0 ;
22252 char *kwnames[] = {
22253 (char *) "self",(char *) "realized", NULL
22254 };
22255
22256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22258 if (SWIG_arg_fail(1)) SWIG_fail;
22259 {
22260 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22261 if (SWIG_arg_fail(2)) SWIG_fail;
22262 }
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 (arg1)->SetPaletteRealized(arg2);
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 Py_INCREF(Py_None); resultobj = Py_None;
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22278 PyObject *resultobj = NULL;
22279 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22280 bool result;
22281 PyObject * obj0 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "self", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(1)) SWIG_fail;
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22292
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 {
22297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22298 }
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22306 PyObject *obj;
22307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22308 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22309 Py_INCREF(obj);
22310 return Py_BuildValue((char *)"");
22311 }
22312 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22313 PyObject *resultobj = NULL;
22314 wxNavigationKeyEvent *result;
22315 char *kwnames[] = {
22316 NULL
22317 };
22318
22319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22323
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22335 PyObject *resultobj = NULL;
22336 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22337 bool result;
22338 PyObject * obj0 = 0 ;
22339 char *kwnames[] = {
22340 (char *) "self", NULL
22341 };
22342
22343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22345 if (SWIG_arg_fail(1)) SWIG_fail;
22346 {
22347 PyThreadState* __tstate = wxPyBeginAllowThreads();
22348 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22349
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 {
22354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22355 }
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22363 PyObject *resultobj = NULL;
22364 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22365 bool arg2 ;
22366 PyObject * obj0 = 0 ;
22367 PyObject * obj1 = 0 ;
22368 char *kwnames[] = {
22369 (char *) "self",(char *) "forward", NULL
22370 };
22371
22372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22374 if (SWIG_arg_fail(1)) SWIG_fail;
22375 {
22376 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22377 if (SWIG_arg_fail(2)) SWIG_fail;
22378 }
22379 {
22380 PyThreadState* __tstate = wxPyBeginAllowThreads();
22381 (arg1)->SetDirection(arg2);
22382
22383 wxPyEndAllowThreads(__tstate);
22384 if (PyErr_Occurred()) SWIG_fail;
22385 }
22386 Py_INCREF(Py_None); resultobj = Py_None;
22387 return resultobj;
22388 fail:
22389 return NULL;
22390 }
22391
22392
22393 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22394 PyObject *resultobj = NULL;
22395 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22396 bool result;
22397 PyObject * obj0 = 0 ;
22398 char *kwnames[] = {
22399 (char *) "self", NULL
22400 };
22401
22402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22404 if (SWIG_arg_fail(1)) SWIG_fail;
22405 {
22406 PyThreadState* __tstate = wxPyBeginAllowThreads();
22407 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22408
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 {
22413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22414 }
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22422 PyObject *resultobj = NULL;
22423 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22424 bool arg2 ;
22425 PyObject * obj0 = 0 ;
22426 PyObject * obj1 = 0 ;
22427 char *kwnames[] = {
22428 (char *) "self",(char *) "ischange", NULL
22429 };
22430
22431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22433 if (SWIG_arg_fail(1)) SWIG_fail;
22434 {
22435 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22436 if (SWIG_arg_fail(2)) SWIG_fail;
22437 }
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 (arg1)->SetWindowChange(arg2);
22441
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 Py_INCREF(Py_None); resultobj = Py_None;
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22453 PyObject *resultobj = NULL;
22454 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22455 bool result;
22456 PyObject * obj0 = 0 ;
22457 char *kwnames[] = {
22458 (char *) "self", NULL
22459 };
22460
22461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22463 if (SWIG_arg_fail(1)) SWIG_fail;
22464 {
22465 PyThreadState* __tstate = wxPyBeginAllowThreads();
22466 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22467
22468 wxPyEndAllowThreads(__tstate);
22469 if (PyErr_Occurred()) SWIG_fail;
22470 }
22471 {
22472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22473 }
22474 return resultobj;
22475 fail:
22476 return NULL;
22477 }
22478
22479
22480 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22481 PyObject *resultobj = NULL;
22482 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22483 bool arg2 ;
22484 PyObject * obj0 = 0 ;
22485 PyObject * obj1 = 0 ;
22486 char *kwnames[] = {
22487 (char *) "self",(char *) "bIs", NULL
22488 };
22489
22490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22492 if (SWIG_arg_fail(1)) SWIG_fail;
22493 {
22494 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22495 if (SWIG_arg_fail(2)) SWIG_fail;
22496 }
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 (arg1)->SetFromTab(arg2);
22500
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 Py_INCREF(Py_None); resultobj = Py_None;
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22512 PyObject *resultobj = NULL;
22513 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22514 long arg2 ;
22515 PyObject * obj0 = 0 ;
22516 PyObject * obj1 = 0 ;
22517 char *kwnames[] = {
22518 (char *) "self",(char *) "flags", NULL
22519 };
22520
22521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22523 if (SWIG_arg_fail(1)) SWIG_fail;
22524 {
22525 arg2 = static_cast<long >(SWIG_As_long(obj1));
22526 if (SWIG_arg_fail(2)) SWIG_fail;
22527 }
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 (arg1)->SetFlags(arg2);
22531
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 Py_INCREF(Py_None); resultobj = Py_None;
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22543 PyObject *resultobj = NULL;
22544 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22545 wxWindow *result;
22546 PyObject * obj0 = 0 ;
22547 char *kwnames[] = {
22548 (char *) "self", NULL
22549 };
22550
22551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22553 if (SWIG_arg_fail(1)) SWIG_fail;
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22557
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 {
22562 resultobj = wxPyMake_wxObject(result, 0);
22563 }
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj = NULL;
22572 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22573 wxWindow *arg2 = (wxWindow *) 0 ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 char *kwnames[] = {
22577 (char *) "self",(char *) "win", NULL
22578 };
22579
22580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22582 if (SWIG_arg_fail(1)) SWIG_fail;
22583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22584 if (SWIG_arg_fail(2)) SWIG_fail;
22585 {
22586 PyThreadState* __tstate = wxPyBeginAllowThreads();
22587 (arg1)->SetCurrentFocus(arg2);
22588
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 Py_INCREF(Py_None); resultobj = Py_None;
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22600 PyObject *obj;
22601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22602 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22603 Py_INCREF(obj);
22604 return Py_BuildValue((char *)"");
22605 }
22606 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22607 PyObject *resultobj = NULL;
22608 wxWindow *arg1 = (wxWindow *) NULL ;
22609 wxWindowCreateEvent *result;
22610 PyObject * obj0 = 0 ;
22611 char *kwnames[] = {
22612 (char *) "win", NULL
22613 };
22614
22615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22616 if (obj0) {
22617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22618 if (SWIG_arg_fail(1)) SWIG_fail;
22619 }
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22623
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22635 PyObject *resultobj = NULL;
22636 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22637 wxWindow *result;
22638 PyObject * obj0 = 0 ;
22639 char *kwnames[] = {
22640 (char *) "self", NULL
22641 };
22642
22643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22645 if (SWIG_arg_fail(1)) SWIG_fail;
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22649
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 {
22654 resultobj = wxPyMake_wxObject(result, 0);
22655 }
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22663 PyObject *obj;
22664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22665 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22666 Py_INCREF(obj);
22667 return Py_BuildValue((char *)"");
22668 }
22669 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22670 PyObject *resultobj = NULL;
22671 wxWindow *arg1 = (wxWindow *) NULL ;
22672 wxWindowDestroyEvent *result;
22673 PyObject * obj0 = 0 ;
22674 char *kwnames[] = {
22675 (char *) "win", NULL
22676 };
22677
22678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22679 if (obj0) {
22680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22681 if (SWIG_arg_fail(1)) SWIG_fail;
22682 }
22683 {
22684 PyThreadState* __tstate = wxPyBeginAllowThreads();
22685 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22686
22687 wxPyEndAllowThreads(__tstate);
22688 if (PyErr_Occurred()) SWIG_fail;
22689 }
22690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22698 PyObject *resultobj = NULL;
22699 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22700 wxWindow *result;
22701 PyObject * obj0 = 0 ;
22702 char *kwnames[] = {
22703 (char *) "self", NULL
22704 };
22705
22706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22708 if (SWIG_arg_fail(1)) SWIG_fail;
22709 {
22710 PyThreadState* __tstate = wxPyBeginAllowThreads();
22711 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22712
22713 wxPyEndAllowThreads(__tstate);
22714 if (PyErr_Occurred()) SWIG_fail;
22715 }
22716 {
22717 resultobj = wxPyMake_wxObject(result, 0);
22718 }
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22726 PyObject *obj;
22727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22728 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22729 Py_INCREF(obj);
22730 return Py_BuildValue((char *)"");
22731 }
22732 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22733 PyObject *resultobj = NULL;
22734 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22735 int arg2 = (int) 0 ;
22736 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22737 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22738 wxContextMenuEvent *result;
22739 wxPoint temp3 ;
22740 PyObject * obj0 = 0 ;
22741 PyObject * obj1 = 0 ;
22742 PyObject * obj2 = 0 ;
22743 char *kwnames[] = {
22744 (char *) "type",(char *) "winid",(char *) "pt", NULL
22745 };
22746
22747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22748 if (obj0) {
22749 {
22750 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22751 if (SWIG_arg_fail(1)) SWIG_fail;
22752 }
22753 }
22754 if (obj1) {
22755 {
22756 arg2 = static_cast<int >(SWIG_As_int(obj1));
22757 if (SWIG_arg_fail(2)) SWIG_fail;
22758 }
22759 }
22760 if (obj2) {
22761 {
22762 arg3 = &temp3;
22763 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22764 }
22765 }
22766 {
22767 PyThreadState* __tstate = wxPyBeginAllowThreads();
22768 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22769
22770 wxPyEndAllowThreads(__tstate);
22771 if (PyErr_Occurred()) SWIG_fail;
22772 }
22773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22774 return resultobj;
22775 fail:
22776 return NULL;
22777 }
22778
22779
22780 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj = NULL;
22782 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22783 wxPoint *result;
22784 PyObject * obj0 = 0 ;
22785 char *kwnames[] = {
22786 (char *) "self", NULL
22787 };
22788
22789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(1)) SWIG_fail;
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 {
22795 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22796 result = (wxPoint *) &_result_ref;
22797 }
22798
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22810 PyObject *resultobj = NULL;
22811 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22812 wxPoint *arg2 = 0 ;
22813 wxPoint temp2 ;
22814 PyObject * obj0 = 0 ;
22815 PyObject * obj1 = 0 ;
22816 char *kwnames[] = {
22817 (char *) "self",(char *) "pos", NULL
22818 };
22819
22820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22822 if (SWIG_arg_fail(1)) SWIG_fail;
22823 {
22824 arg2 = &temp2;
22825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22826 }
22827 {
22828 PyThreadState* __tstate = wxPyBeginAllowThreads();
22829 (arg1)->SetPosition((wxPoint const &)*arg2);
22830
22831 wxPyEndAllowThreads(__tstate);
22832 if (PyErr_Occurred()) SWIG_fail;
22833 }
22834 Py_INCREF(Py_None); resultobj = Py_None;
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22842 PyObject *obj;
22843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22844 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22845 Py_INCREF(obj);
22846 return Py_BuildValue((char *)"");
22847 }
22848 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj = NULL;
22850 wxIdleEvent *result;
22851 char *kwnames[] = {
22852 NULL
22853 };
22854
22855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (wxIdleEvent *)new wxIdleEvent();
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj = NULL;
22872 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22873 bool arg2 = (bool) true ;
22874 PyObject * obj0 = 0 ;
22875 PyObject * obj1 = 0 ;
22876 char *kwnames[] = {
22877 (char *) "self",(char *) "needMore", NULL
22878 };
22879
22880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22882 if (SWIG_arg_fail(1)) SWIG_fail;
22883 if (obj1) {
22884 {
22885 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22886 if (SWIG_arg_fail(2)) SWIG_fail;
22887 }
22888 }
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 (arg1)->RequestMore(arg2);
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 Py_INCREF(Py_None); resultobj = Py_None;
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22904 PyObject *resultobj = NULL;
22905 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22906 bool result;
22907 PyObject * obj0 = 0 ;
22908 char *kwnames[] = {
22909 (char *) "self", NULL
22910 };
22911
22912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22914 if (SWIG_arg_fail(1)) SWIG_fail;
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22918
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 {
22923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22924 }
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22932 PyObject *resultobj = NULL;
22933 wxIdleMode arg1 ;
22934 PyObject * obj0 = 0 ;
22935 char *kwnames[] = {
22936 (char *) "mode", NULL
22937 };
22938
22939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22940 {
22941 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
22942 if (SWIG_arg_fail(1)) SWIG_fail;
22943 }
22944 {
22945 PyThreadState* __tstate = wxPyBeginAllowThreads();
22946 wxIdleEvent::SetMode(arg1);
22947
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 Py_INCREF(Py_None); resultobj = Py_None;
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22959 PyObject *resultobj = NULL;
22960 wxIdleMode result;
22961 char *kwnames[] = {
22962 NULL
22963 };
22964
22965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22966 {
22967 PyThreadState* __tstate = wxPyBeginAllowThreads();
22968 result = (wxIdleMode)wxIdleEvent::GetMode();
22969
22970 wxPyEndAllowThreads(__tstate);
22971 if (PyErr_Occurred()) SWIG_fail;
22972 }
22973 resultobj = SWIG_From_int((result));
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22981 PyObject *resultobj = NULL;
22982 wxWindow *arg1 = (wxWindow *) 0 ;
22983 bool result;
22984 PyObject * obj0 = 0 ;
22985 char *kwnames[] = {
22986 (char *) "win", NULL
22987 };
22988
22989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22991 if (SWIG_arg_fail(1)) SWIG_fail;
22992 {
22993 PyThreadState* __tstate = wxPyBeginAllowThreads();
22994 result = (bool)wxIdleEvent::CanSend(arg1);
22995
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 {
23000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23001 }
23002 return resultobj;
23003 fail:
23004 return NULL;
23005 }
23006
23007
23008 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23009 PyObject *obj;
23010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23011 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23012 Py_INCREF(obj);
23013 return Py_BuildValue((char *)"");
23014 }
23015 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23016 PyObject *resultobj = NULL;
23017 int arg1 = (int) 0 ;
23018 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23019 wxPyEvent *result;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022 char *kwnames[] = {
23023 (char *) "winid",(char *) "eventType", NULL
23024 };
23025
23026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23027 if (obj0) {
23028 {
23029 arg1 = static_cast<int >(SWIG_As_int(obj0));
23030 if (SWIG_arg_fail(1)) SWIG_fail;
23031 }
23032 }
23033 if (obj1) {
23034 {
23035 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23036 if (SWIG_arg_fail(2)) SWIG_fail;
23037 }
23038 }
23039 {
23040 PyThreadState* __tstate = wxPyBeginAllowThreads();
23041 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23042
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23047 return resultobj;
23048 fail:
23049 return NULL;
23050 }
23051
23052
23053 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23054 PyObject *resultobj = NULL;
23055 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23056 PyObject * obj0 = 0 ;
23057 char *kwnames[] = {
23058 (char *) "self", NULL
23059 };
23060
23061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23063 if (SWIG_arg_fail(1)) SWIG_fail;
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 delete arg1;
23067
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 Py_INCREF(Py_None); resultobj = Py_None;
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23079 PyObject *resultobj = NULL;
23080 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23081 PyObject *arg2 = (PyObject *) 0 ;
23082 PyObject * obj0 = 0 ;
23083 PyObject * obj1 = 0 ;
23084 char *kwnames[] = {
23085 (char *) "self",(char *) "self", NULL
23086 };
23087
23088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23090 if (SWIG_arg_fail(1)) SWIG_fail;
23091 arg2 = obj1;
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 (arg1)->SetSelf(arg2);
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 Py_INCREF(Py_None); resultobj = Py_None;
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj = NULL;
23108 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23109 PyObject *result;
23110 PyObject * obj0 = 0 ;
23111 char *kwnames[] = {
23112 (char *) "self", NULL
23113 };
23114
23115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23117 if (SWIG_arg_fail(1)) SWIG_fail;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (PyObject *)(arg1)->GetSelf();
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 resultobj = result;
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23133 PyObject *obj;
23134 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23135 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23136 Py_INCREF(obj);
23137 return Py_BuildValue((char *)"");
23138 }
23139 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23140 PyObject *resultobj = NULL;
23141 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23142 int arg2 = (int) 0 ;
23143 wxPyCommandEvent *result;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146 char *kwnames[] = {
23147 (char *) "eventType",(char *) "id", NULL
23148 };
23149
23150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23151 if (obj0) {
23152 {
23153 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23154 if (SWIG_arg_fail(1)) SWIG_fail;
23155 }
23156 }
23157 if (obj1) {
23158 {
23159 arg2 = static_cast<int >(SWIG_As_int(obj1));
23160 if (SWIG_arg_fail(2)) SWIG_fail;
23161 }
23162 }
23163 {
23164 PyThreadState* __tstate = wxPyBeginAllowThreads();
23165 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23166
23167 wxPyEndAllowThreads(__tstate);
23168 if (PyErr_Occurred()) SWIG_fail;
23169 }
23170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23171 return resultobj;
23172 fail:
23173 return NULL;
23174 }
23175
23176
23177 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23178 PyObject *resultobj = NULL;
23179 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23180 PyObject * obj0 = 0 ;
23181 char *kwnames[] = {
23182 (char *) "self", NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(1)) SWIG_fail;
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 delete arg1;
23191
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 Py_INCREF(Py_None); resultobj = Py_None;
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj = NULL;
23204 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23205 PyObject *arg2 = (PyObject *) 0 ;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char *kwnames[] = {
23209 (char *) "self",(char *) "self", NULL
23210 };
23211
23212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23214 if (SWIG_arg_fail(1)) SWIG_fail;
23215 arg2 = obj1;
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 (arg1)->SetSelf(arg2);
23219
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 Py_INCREF(Py_None); resultobj = Py_None;
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23231 PyObject *resultobj = NULL;
23232 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23233 PyObject *result;
23234 PyObject * obj0 = 0 ;
23235 char *kwnames[] = {
23236 (char *) "self", NULL
23237 };
23238
23239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23241 if (SWIG_arg_fail(1)) SWIG_fail;
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (PyObject *)(arg1)->GetSelf();
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = result;
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23257 PyObject *obj;
23258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23259 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23260 Py_INCREF(obj);
23261 return Py_BuildValue((char *)"");
23262 }
23263 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23264 PyObject *resultobj = NULL;
23265 wxWindow *arg1 = (wxWindow *) 0 ;
23266 wxDateTime *arg2 = 0 ;
23267 wxEventType arg3 ;
23268 wxDateEvent *result;
23269 PyObject * obj0 = 0 ;
23270 PyObject * obj1 = 0 ;
23271 PyObject * obj2 = 0 ;
23272 char *kwnames[] = {
23273 (char *) "win",(char *) "dt",(char *) "type", NULL
23274 };
23275
23276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23278 if (SWIG_arg_fail(1)) SWIG_fail;
23279 {
23280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23281 if (SWIG_arg_fail(2)) SWIG_fail;
23282 if (arg2 == NULL) {
23283 SWIG_null_ref("wxDateTime");
23284 }
23285 if (SWIG_arg_fail(2)) SWIG_fail;
23286 }
23287 {
23288 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23289 if (SWIG_arg_fail(3)) SWIG_fail;
23290 }
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23294
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = NULL;
23307 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23308 wxDateTime *result;
23309 PyObject * obj0 = 0 ;
23310 char *kwnames[] = {
23311 (char *) "self", NULL
23312 };
23313
23314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23316 if (SWIG_arg_fail(1)) SWIG_fail;
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 {
23320 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23321 result = (wxDateTime *) &_result_ref;
23322 }
23323
23324 wxPyEndAllowThreads(__tstate);
23325 if (PyErr_Occurred()) SWIG_fail;
23326 }
23327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23335 PyObject *resultobj = NULL;
23336 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23337 wxDateTime *arg2 = 0 ;
23338 PyObject * obj0 = 0 ;
23339 PyObject * obj1 = 0 ;
23340 char *kwnames[] = {
23341 (char *) "self",(char *) "date", NULL
23342 };
23343
23344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23346 if (SWIG_arg_fail(1)) SWIG_fail;
23347 {
23348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23349 if (SWIG_arg_fail(2)) SWIG_fail;
23350 if (arg2 == NULL) {
23351 SWIG_null_ref("wxDateTime");
23352 }
23353 if (SWIG_arg_fail(2)) SWIG_fail;
23354 }
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 (arg1)->SetDate((wxDateTime const &)*arg2);
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 Py_INCREF(Py_None); resultobj = Py_None;
23363 return resultobj;
23364 fail:
23365 return NULL;
23366 }
23367
23368
23369 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23370 PyObject *obj;
23371 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23372 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23373 Py_INCREF(obj);
23374 return Py_BuildValue((char *)"");
23375 }
23376 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23377 PyObject *resultobj = NULL;
23378 wxPyApp *result;
23379 char *kwnames[] = {
23380 NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23384 {
23385 PyThreadState* __tstate = wxPyBeginAllowThreads();
23386 result = (wxPyApp *)new_wxPyApp();
23387
23388 wxPyEndAllowThreads(__tstate);
23389 if (PyErr_Occurred()) SWIG_fail;
23390 }
23391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23399 PyObject *resultobj = NULL;
23400 wxPyApp *arg1 = (wxPyApp *) 0 ;
23401 PyObject * obj0 = 0 ;
23402 char *kwnames[] = {
23403 (char *) "self", NULL
23404 };
23405
23406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23408 if (SWIG_arg_fail(1)) SWIG_fail;
23409 {
23410 PyThreadState* __tstate = wxPyBeginAllowThreads();
23411 delete arg1;
23412
23413 wxPyEndAllowThreads(__tstate);
23414 if (PyErr_Occurred()) SWIG_fail;
23415 }
23416 Py_INCREF(Py_None); resultobj = Py_None;
23417 return resultobj;
23418 fail:
23419 return NULL;
23420 }
23421
23422
23423 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23424 PyObject *resultobj = NULL;
23425 wxPyApp *arg1 = (wxPyApp *) 0 ;
23426 PyObject *arg2 = (PyObject *) 0 ;
23427 PyObject *arg3 = (PyObject *) 0 ;
23428 bool arg4 ;
23429 PyObject * obj0 = 0 ;
23430 PyObject * obj1 = 0 ;
23431 PyObject * obj2 = 0 ;
23432 PyObject * obj3 = 0 ;
23433 char *kwnames[] = {
23434 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23435 };
23436
23437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23439 if (SWIG_arg_fail(1)) SWIG_fail;
23440 arg2 = obj1;
23441 arg3 = obj2;
23442 {
23443 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23444 if (SWIG_arg_fail(4)) SWIG_fail;
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23449
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 Py_INCREF(Py_None); resultobj = Py_None;
23454 return resultobj;
23455 fail:
23456 return NULL;
23457 }
23458
23459
23460 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23461 PyObject *resultobj = NULL;
23462 wxPyApp *arg1 = (wxPyApp *) 0 ;
23463 wxString result;
23464 PyObject * obj0 = 0 ;
23465 char *kwnames[] = {
23466 (char *) "self", NULL
23467 };
23468
23469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23471 if (SWIG_arg_fail(1)) SWIG_fail;
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = ((wxPyApp const *)arg1)->GetAppName();
23475
23476 wxPyEndAllowThreads(__tstate);
23477 if (PyErr_Occurred()) SWIG_fail;
23478 }
23479 {
23480 #if wxUSE_UNICODE
23481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23482 #else
23483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23484 #endif
23485 }
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = NULL;
23494 wxPyApp *arg1 = (wxPyApp *) 0 ;
23495 wxString *arg2 = 0 ;
23496 bool temp2 = false ;
23497 PyObject * obj0 = 0 ;
23498 PyObject * obj1 = 0 ;
23499 char *kwnames[] = {
23500 (char *) "self",(char *) "name", NULL
23501 };
23502
23503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23505 if (SWIG_arg_fail(1)) SWIG_fail;
23506 {
23507 arg2 = wxString_in_helper(obj1);
23508 if (arg2 == NULL) SWIG_fail;
23509 temp2 = true;
23510 }
23511 {
23512 PyThreadState* __tstate = wxPyBeginAllowThreads();
23513 (arg1)->SetAppName((wxString const &)*arg2);
23514
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 Py_INCREF(Py_None); resultobj = Py_None;
23519 {
23520 if (temp2)
23521 delete arg2;
23522 }
23523 return resultobj;
23524 fail:
23525 {
23526 if (temp2)
23527 delete arg2;
23528 }
23529 return NULL;
23530 }
23531
23532
23533 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23534 PyObject *resultobj = NULL;
23535 wxPyApp *arg1 = (wxPyApp *) 0 ;
23536 wxString result;
23537 PyObject * obj0 = 0 ;
23538 char *kwnames[] = {
23539 (char *) "self", NULL
23540 };
23541
23542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23544 if (SWIG_arg_fail(1)) SWIG_fail;
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 result = ((wxPyApp const *)arg1)->GetClassName();
23548
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 #if wxUSE_UNICODE
23554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23555 #else
23556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23557 #endif
23558 }
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = NULL;
23567 wxPyApp *arg1 = (wxPyApp *) 0 ;
23568 wxString *arg2 = 0 ;
23569 bool temp2 = false ;
23570 PyObject * obj0 = 0 ;
23571 PyObject * obj1 = 0 ;
23572 char *kwnames[] = {
23573 (char *) "self",(char *) "name", NULL
23574 };
23575
23576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23578 if (SWIG_arg_fail(1)) SWIG_fail;
23579 {
23580 arg2 = wxString_in_helper(obj1);
23581 if (arg2 == NULL) SWIG_fail;
23582 temp2 = true;
23583 }
23584 {
23585 PyThreadState* __tstate = wxPyBeginAllowThreads();
23586 (arg1)->SetClassName((wxString const &)*arg2);
23587
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 Py_INCREF(Py_None); resultobj = Py_None;
23592 {
23593 if (temp2)
23594 delete arg2;
23595 }
23596 return resultobj;
23597 fail:
23598 {
23599 if (temp2)
23600 delete arg2;
23601 }
23602 return NULL;
23603 }
23604
23605
23606 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23607 PyObject *resultobj = NULL;
23608 wxPyApp *arg1 = (wxPyApp *) 0 ;
23609 wxString *result;
23610 PyObject * obj0 = 0 ;
23611 char *kwnames[] = {
23612 (char *) "self", NULL
23613 };
23614
23615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23617 if (SWIG_arg_fail(1)) SWIG_fail;
23618 {
23619 PyThreadState* __tstate = wxPyBeginAllowThreads();
23620 {
23621 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23622 result = (wxString *) &_result_ref;
23623 }
23624
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 #if wxUSE_UNICODE
23630 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23631 #else
23632 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23633 #endif
23634 }
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = NULL;
23643 wxPyApp *arg1 = (wxPyApp *) 0 ;
23644 wxString *arg2 = 0 ;
23645 bool temp2 = false ;
23646 PyObject * obj0 = 0 ;
23647 PyObject * obj1 = 0 ;
23648 char *kwnames[] = {
23649 (char *) "self",(char *) "name", NULL
23650 };
23651
23652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23654 if (SWIG_arg_fail(1)) SWIG_fail;
23655 {
23656 arg2 = wxString_in_helper(obj1);
23657 if (arg2 == NULL) SWIG_fail;
23658 temp2 = true;
23659 }
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 (arg1)->SetVendorName((wxString const &)*arg2);
23663
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 Py_INCREF(Py_None); resultobj = Py_None;
23668 {
23669 if (temp2)
23670 delete arg2;
23671 }
23672 return resultobj;
23673 fail:
23674 {
23675 if (temp2)
23676 delete arg2;
23677 }
23678 return NULL;
23679 }
23680
23681
23682 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23683 PyObject *resultobj = NULL;
23684 wxPyApp *arg1 = (wxPyApp *) 0 ;
23685 wxAppTraits *result;
23686 PyObject * obj0 = 0 ;
23687 char *kwnames[] = {
23688 (char *) "self", NULL
23689 };
23690
23691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23693 if (SWIG_arg_fail(1)) SWIG_fail;
23694 {
23695 PyThreadState* __tstate = wxPyBeginAllowThreads();
23696 result = (wxAppTraits *)(arg1)->GetTraits();
23697
23698 wxPyEndAllowThreads(__tstate);
23699 if (PyErr_Occurred()) SWIG_fail;
23700 }
23701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23702 return resultobj;
23703 fail:
23704 return NULL;
23705 }
23706
23707
23708 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23709 PyObject *resultobj = NULL;
23710 wxPyApp *arg1 = (wxPyApp *) 0 ;
23711 PyObject * obj0 = 0 ;
23712 char *kwnames[] = {
23713 (char *) "self", NULL
23714 };
23715
23716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23718 if (SWIG_arg_fail(1)) SWIG_fail;
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 (arg1)->ProcessPendingEvents();
23722
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 Py_INCREF(Py_None); resultobj = Py_None;
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23734 PyObject *resultobj = NULL;
23735 wxPyApp *arg1 = (wxPyApp *) 0 ;
23736 bool arg2 = (bool) false ;
23737 bool result;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 char *kwnames[] = {
23741 (char *) "self",(char *) "onlyIfNeeded", NULL
23742 };
23743
23744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23746 if (SWIG_arg_fail(1)) SWIG_fail;
23747 if (obj1) {
23748 {
23749 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23750 if (SWIG_arg_fail(2)) SWIG_fail;
23751 }
23752 }
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 result = (bool)(arg1)->Yield(arg2);
23756
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 {
23761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23762 }
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23770 PyObject *resultobj = NULL;
23771 wxPyApp *arg1 = (wxPyApp *) 0 ;
23772 PyObject * obj0 = 0 ;
23773 char *kwnames[] = {
23774 (char *) "self", NULL
23775 };
23776
23777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23779 if (SWIG_arg_fail(1)) SWIG_fail;
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 (arg1)->WakeUpIdle();
23783
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 Py_INCREF(Py_None); resultobj = Py_None;
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23795 PyObject *resultobj = NULL;
23796 bool result;
23797 char *kwnames[] = {
23798 NULL
23799 };
23800
23801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = (bool)wxPyApp::IsMainLoopRunning();
23805
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj = NULL;
23820 wxPyApp *arg1 = (wxPyApp *) 0 ;
23821 int result;
23822 PyObject * obj0 = 0 ;
23823 char *kwnames[] = {
23824 (char *) "self", NULL
23825 };
23826
23827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23829 if (SWIG_arg_fail(1)) SWIG_fail;
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 result = (int)(arg1)->MainLoop();
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 {
23838 resultobj = SWIG_From_int(static_cast<int >(result));
23839 }
23840 return resultobj;
23841 fail:
23842 return NULL;
23843 }
23844
23845
23846 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23847 PyObject *resultobj = NULL;
23848 wxPyApp *arg1 = (wxPyApp *) 0 ;
23849 PyObject * obj0 = 0 ;
23850 char *kwnames[] = {
23851 (char *) "self", NULL
23852 };
23853
23854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23856 if (SWIG_arg_fail(1)) SWIG_fail;
23857 {
23858 PyThreadState* __tstate = wxPyBeginAllowThreads();
23859 (arg1)->Exit();
23860
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 Py_INCREF(Py_None); resultobj = Py_None;
23865 return resultobj;
23866 fail:
23867 return NULL;
23868 }
23869
23870
23871 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23872 PyObject *resultobj = NULL;
23873 wxPyApp *arg1 = (wxPyApp *) 0 ;
23874 PyObject * obj0 = 0 ;
23875 char *kwnames[] = {
23876 (char *) "self", NULL
23877 };
23878
23879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23881 if (SWIG_arg_fail(1)) SWIG_fail;
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 (arg1)->ExitMainLoop();
23885
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 Py_INCREF(Py_None); resultobj = Py_None;
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23897 PyObject *resultobj = NULL;
23898 wxPyApp *arg1 = (wxPyApp *) 0 ;
23899 bool result;
23900 PyObject * obj0 = 0 ;
23901 char *kwnames[] = {
23902 (char *) "self", NULL
23903 };
23904
23905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23907 if (SWIG_arg_fail(1)) SWIG_fail;
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = (bool)(arg1)->Pending();
23911
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 {
23916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23917 }
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23925 PyObject *resultobj = NULL;
23926 wxPyApp *arg1 = (wxPyApp *) 0 ;
23927 bool result;
23928 PyObject * obj0 = 0 ;
23929 char *kwnames[] = {
23930 (char *) "self", NULL
23931 };
23932
23933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23935 if (SWIG_arg_fail(1)) SWIG_fail;
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (bool)(arg1)->Dispatch();
23939
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 {
23944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23945 }
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj = NULL;
23954 wxPyApp *arg1 = (wxPyApp *) 0 ;
23955 bool result;
23956 PyObject * obj0 = 0 ;
23957 char *kwnames[] = {
23958 (char *) "self", NULL
23959 };
23960
23961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23963 if (SWIG_arg_fail(1)) SWIG_fail;
23964 {
23965 PyThreadState* __tstate = wxPyBeginAllowThreads();
23966 result = (bool)(arg1)->ProcessIdle();
23967
23968 wxPyEndAllowThreads(__tstate);
23969 if (PyErr_Occurred()) SWIG_fail;
23970 }
23971 {
23972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23973 }
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23981 PyObject *resultobj = NULL;
23982 wxPyApp *arg1 = (wxPyApp *) 0 ;
23983 wxWindow *arg2 = (wxWindow *) 0 ;
23984 wxIdleEvent *arg3 = 0 ;
23985 bool result;
23986 PyObject * obj0 = 0 ;
23987 PyObject * obj1 = 0 ;
23988 PyObject * obj2 = 0 ;
23989 char *kwnames[] = {
23990 (char *) "self",(char *) "win",(char *) "event", NULL
23991 };
23992
23993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23995 if (SWIG_arg_fail(1)) SWIG_fail;
23996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23997 if (SWIG_arg_fail(2)) SWIG_fail;
23998 {
23999 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24000 if (SWIG_arg_fail(3)) SWIG_fail;
24001 if (arg3 == NULL) {
24002 SWIG_null_ref("wxIdleEvent");
24003 }
24004 if (SWIG_arg_fail(3)) SWIG_fail;
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24009
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj = NULL;
24024 wxPyApp *arg1 = (wxPyApp *) 0 ;
24025 bool result;
24026 PyObject * obj0 = 0 ;
24027 char *kwnames[] = {
24028 (char *) "self", NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24033 if (SWIG_arg_fail(1)) SWIG_fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (bool)((wxPyApp const *)arg1)->IsActive();
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 {
24042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24043 }
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24051 PyObject *resultobj = NULL;
24052 wxPyApp *arg1 = (wxPyApp *) 0 ;
24053 wxWindow *arg2 = (wxWindow *) 0 ;
24054 PyObject * obj0 = 0 ;
24055 PyObject * obj1 = 0 ;
24056 char *kwnames[] = {
24057 (char *) "self",(char *) "win", NULL
24058 };
24059
24060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24062 if (SWIG_arg_fail(1)) SWIG_fail;
24063 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24064 if (SWIG_arg_fail(2)) SWIG_fail;
24065 {
24066 PyThreadState* __tstate = wxPyBeginAllowThreads();
24067 (arg1)->SetTopWindow(arg2);
24068
24069 wxPyEndAllowThreads(__tstate);
24070 if (PyErr_Occurred()) SWIG_fail;
24071 }
24072 Py_INCREF(Py_None); resultobj = Py_None;
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24080 PyObject *resultobj = NULL;
24081 wxPyApp *arg1 = (wxPyApp *) 0 ;
24082 wxWindow *result;
24083 PyObject * obj0 = 0 ;
24084 char *kwnames[] = {
24085 (char *) "self", NULL
24086 };
24087
24088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24090 if (SWIG_arg_fail(1)) SWIG_fail;
24091 {
24092 PyThreadState* __tstate = wxPyBeginAllowThreads();
24093 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24094
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 {
24099 resultobj = wxPyMake_wxObject(result, 0);
24100 }
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24108 PyObject *resultobj = NULL;
24109 wxPyApp *arg1 = (wxPyApp *) 0 ;
24110 bool arg2 ;
24111 PyObject * obj0 = 0 ;
24112 PyObject * obj1 = 0 ;
24113 char *kwnames[] = {
24114 (char *) "self",(char *) "flag", NULL
24115 };
24116
24117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24119 if (SWIG_arg_fail(1)) SWIG_fail;
24120 {
24121 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24122 if (SWIG_arg_fail(2)) SWIG_fail;
24123 }
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 (arg1)->SetExitOnFrameDelete(arg2);
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 Py_INCREF(Py_None); resultobj = Py_None;
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj = NULL;
24140 wxPyApp *arg1 = (wxPyApp *) 0 ;
24141 bool result;
24142 PyObject * obj0 = 0 ;
24143 char *kwnames[] = {
24144 (char *) "self", NULL
24145 };
24146
24147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24149 if (SWIG_arg_fail(1)) SWIG_fail;
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24153
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 {
24158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24159 }
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj = NULL;
24168 wxPyApp *arg1 = (wxPyApp *) 0 ;
24169 bool arg2 ;
24170 PyObject * obj0 = 0 ;
24171 PyObject * obj1 = 0 ;
24172 char *kwnames[] = {
24173 (char *) "self",(char *) "flag", NULL
24174 };
24175
24176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24178 if (SWIG_arg_fail(1)) SWIG_fail;
24179 {
24180 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24181 if (SWIG_arg_fail(2)) SWIG_fail;
24182 }
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 (arg1)->SetUseBestVisual(arg2);
24186
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 Py_INCREF(Py_None); resultobj = Py_None;
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj = NULL;
24199 wxPyApp *arg1 = (wxPyApp *) 0 ;
24200 bool result;
24201 PyObject * obj0 = 0 ;
24202 char *kwnames[] = {
24203 (char *) "self", NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24208 if (SWIG_arg_fail(1)) SWIG_fail;
24209 {
24210 PyThreadState* __tstate = wxPyBeginAllowThreads();
24211 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24212
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 {
24217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24218 }
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24226 PyObject *resultobj = NULL;
24227 wxPyApp *arg1 = (wxPyApp *) 0 ;
24228 int arg2 ;
24229 PyObject * obj0 = 0 ;
24230 PyObject * obj1 = 0 ;
24231 char *kwnames[] = {
24232 (char *) "self",(char *) "mode", NULL
24233 };
24234
24235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24237 if (SWIG_arg_fail(1)) SWIG_fail;
24238 {
24239 arg2 = static_cast<int >(SWIG_As_int(obj1));
24240 if (SWIG_arg_fail(2)) SWIG_fail;
24241 }
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 (arg1)->SetPrintMode(arg2);
24245
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 Py_INCREF(Py_None); resultobj = Py_None;
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj = NULL;
24258 wxPyApp *arg1 = (wxPyApp *) 0 ;
24259 int result;
24260 PyObject * obj0 = 0 ;
24261 char *kwnames[] = {
24262 (char *) "self", NULL
24263 };
24264
24265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24267 if (SWIG_arg_fail(1)) SWIG_fail;
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24271
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 {
24276 resultobj = SWIG_From_int(static_cast<int >(result));
24277 }
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj = NULL;
24286 wxPyApp *arg1 = (wxPyApp *) 0 ;
24287 int arg2 ;
24288 PyObject * obj0 = 0 ;
24289 PyObject * obj1 = 0 ;
24290 char *kwnames[] = {
24291 (char *) "self",(char *) "mode", NULL
24292 };
24293
24294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24296 if (SWIG_arg_fail(1)) SWIG_fail;
24297 {
24298 arg2 = static_cast<int >(SWIG_As_int(obj1));
24299 if (SWIG_arg_fail(2)) SWIG_fail;
24300 }
24301 {
24302 PyThreadState* __tstate = wxPyBeginAllowThreads();
24303 (arg1)->SetAssertMode(arg2);
24304
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 Py_INCREF(Py_None); resultobj = Py_None;
24309 return resultobj;
24310 fail:
24311 return NULL;
24312 }
24313
24314
24315 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24316 PyObject *resultobj = NULL;
24317 wxPyApp *arg1 = (wxPyApp *) 0 ;
24318 int result;
24319 PyObject * obj0 = 0 ;
24320 char *kwnames[] = {
24321 (char *) "self", NULL
24322 };
24323
24324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24326 if (SWIG_arg_fail(1)) SWIG_fail;
24327 {
24328 PyThreadState* __tstate = wxPyBeginAllowThreads();
24329 result = (int)(arg1)->GetAssertMode();
24330
24331 wxPyEndAllowThreads(__tstate);
24332 if (PyErr_Occurred()) SWIG_fail;
24333 }
24334 {
24335 resultobj = SWIG_From_int(static_cast<int >(result));
24336 }
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24344 PyObject *resultobj = NULL;
24345 bool result;
24346 char *kwnames[] = {
24347 NULL
24348 };
24349
24350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24351 {
24352 PyThreadState* __tstate = wxPyBeginAllowThreads();
24353 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24354
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 {
24359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24360 }
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj = NULL;
24369 long result;
24370 char *kwnames[] = {
24371 NULL
24372 };
24373
24374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 result = (long)wxPyApp::GetMacAboutMenuItemId();
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 {
24383 resultobj = SWIG_From_long(static_cast<long >(result));
24384 }
24385 return resultobj;
24386 fail:
24387 return NULL;
24388 }
24389
24390
24391 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24392 PyObject *resultobj = NULL;
24393 long result;
24394 char *kwnames[] = {
24395 NULL
24396 };
24397
24398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24399 {
24400 PyThreadState* __tstate = wxPyBeginAllowThreads();
24401 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24402
24403 wxPyEndAllowThreads(__tstate);
24404 if (PyErr_Occurred()) SWIG_fail;
24405 }
24406 {
24407 resultobj = SWIG_From_long(static_cast<long >(result));
24408 }
24409 return resultobj;
24410 fail:
24411 return NULL;
24412 }
24413
24414
24415 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj = NULL;
24417 long result;
24418 char *kwnames[] = {
24419 NULL
24420 };
24421
24422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (long)wxPyApp::GetMacExitMenuItemId();
24426
24427 wxPyEndAllowThreads(__tstate);
24428 if (PyErr_Occurred()) SWIG_fail;
24429 }
24430 {
24431 resultobj = SWIG_From_long(static_cast<long >(result));
24432 }
24433 return resultobj;
24434 fail:
24435 return NULL;
24436 }
24437
24438
24439 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24440 PyObject *resultobj = NULL;
24441 wxString result;
24442 char *kwnames[] = {
24443 NULL
24444 };
24445
24446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = wxPyApp::GetMacHelpMenuTitleName();
24450
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 {
24455 #if wxUSE_UNICODE
24456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24457 #else
24458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24459 #endif
24460 }
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj = NULL;
24469 bool arg1 ;
24470 PyObject * obj0 = 0 ;
24471 char *kwnames[] = {
24472 (char *) "val", NULL
24473 };
24474
24475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24476 {
24477 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24478 if (SWIG_arg_fail(1)) SWIG_fail;
24479 }
24480 {
24481 PyThreadState* __tstate = wxPyBeginAllowThreads();
24482 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24483
24484 wxPyEndAllowThreads(__tstate);
24485 if (PyErr_Occurred()) SWIG_fail;
24486 }
24487 Py_INCREF(Py_None); resultobj = Py_None;
24488 return resultobj;
24489 fail:
24490 return NULL;
24491 }
24492
24493
24494 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24495 PyObject *resultobj = NULL;
24496 long arg1 ;
24497 PyObject * obj0 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "val", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24503 {
24504 arg1 = static_cast<long >(SWIG_As_long(obj0));
24505 if (SWIG_arg_fail(1)) SWIG_fail;
24506 }
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 wxPyApp::SetMacAboutMenuItemId(arg1);
24510
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 Py_INCREF(Py_None); resultobj = Py_None;
24515 return resultobj;
24516 fail:
24517 return NULL;
24518 }
24519
24520
24521 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24522 PyObject *resultobj = NULL;
24523 long arg1 ;
24524 PyObject * obj0 = 0 ;
24525 char *kwnames[] = {
24526 (char *) "val", NULL
24527 };
24528
24529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24530 {
24531 arg1 = static_cast<long >(SWIG_As_long(obj0));
24532 if (SWIG_arg_fail(1)) SWIG_fail;
24533 }
24534 {
24535 PyThreadState* __tstate = wxPyBeginAllowThreads();
24536 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24537
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 Py_INCREF(Py_None); resultobj = Py_None;
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj = NULL;
24550 long arg1 ;
24551 PyObject * obj0 = 0 ;
24552 char *kwnames[] = {
24553 (char *) "val", NULL
24554 };
24555
24556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24557 {
24558 arg1 = static_cast<long >(SWIG_As_long(obj0));
24559 if (SWIG_arg_fail(1)) SWIG_fail;
24560 }
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 wxPyApp::SetMacExitMenuItemId(arg1);
24564
24565 wxPyEndAllowThreads(__tstate);
24566 if (PyErr_Occurred()) SWIG_fail;
24567 }
24568 Py_INCREF(Py_None); resultobj = Py_None;
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj = NULL;
24577 wxString *arg1 = 0 ;
24578 bool temp1 = false ;
24579 PyObject * obj0 = 0 ;
24580 char *kwnames[] = {
24581 (char *) "val", NULL
24582 };
24583
24584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24585 {
24586 arg1 = wxString_in_helper(obj0);
24587 if (arg1 == NULL) SWIG_fail;
24588 temp1 = true;
24589 }
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 Py_INCREF(Py_None); resultobj = Py_None;
24598 {
24599 if (temp1)
24600 delete arg1;
24601 }
24602 return resultobj;
24603 fail:
24604 {
24605 if (temp1)
24606 delete arg1;
24607 }
24608 return NULL;
24609 }
24610
24611
24612 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24613 PyObject *resultobj = NULL;
24614 wxPyApp *arg1 = (wxPyApp *) 0 ;
24615 PyObject * obj0 = 0 ;
24616 char *kwnames[] = {
24617 (char *) "self", NULL
24618 };
24619
24620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24622 if (SWIG_arg_fail(1)) SWIG_fail;
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 (arg1)->_BootstrapApp();
24626
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 Py_INCREF(Py_None); resultobj = Py_None;
24631 return resultobj;
24632 fail:
24633 return NULL;
24634 }
24635
24636
24637 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24638 PyObject *resultobj = NULL;
24639 int result;
24640 char *kwnames[] = {
24641 NULL
24642 };
24643
24644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (int)wxPyApp::GetComCtl32Version();
24648
24649 wxPyEndAllowThreads(__tstate);
24650 if (PyErr_Occurred()) SWIG_fail;
24651 }
24652 {
24653 resultobj = SWIG_From_int(static_cast<int >(result));
24654 }
24655 return resultobj;
24656 fail:
24657 return NULL;
24658 }
24659
24660
24661 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24662 PyObject *obj;
24663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24664 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24665 Py_INCREF(obj);
24666 return Py_BuildValue((char *)"");
24667 }
24668 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = NULL;
24670 char *kwnames[] = {
24671 NULL
24672 };
24673
24674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 wxExit();
24678
24679 wxPyEndAllowThreads(__tstate);
24680 if (PyErr_Occurred()) SWIG_fail;
24681 }
24682 Py_INCREF(Py_None); resultobj = Py_None;
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj = NULL;
24691 bool result;
24692 char *kwnames[] = {
24693 NULL
24694 };
24695
24696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24697 {
24698 PyThreadState* __tstate = wxPyBeginAllowThreads();
24699 result = (bool)wxYield();
24700
24701 wxPyEndAllowThreads(__tstate);
24702 if (PyErr_Occurred()) SWIG_fail;
24703 }
24704 {
24705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24706 }
24707 return resultobj;
24708 fail:
24709 return NULL;
24710 }
24711
24712
24713 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = NULL;
24715 bool result;
24716 char *kwnames[] = {
24717 NULL
24718 };
24719
24720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24721 {
24722 PyThreadState* __tstate = wxPyBeginAllowThreads();
24723 result = (bool)wxYieldIfNeeded();
24724
24725 wxPyEndAllowThreads(__tstate);
24726 if (PyErr_Occurred()) SWIG_fail;
24727 }
24728 {
24729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24730 }
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24738 PyObject *resultobj = NULL;
24739 wxWindow *arg1 = (wxWindow *) NULL ;
24740 bool arg2 = (bool) false ;
24741 bool result;
24742 PyObject * obj0 = 0 ;
24743 PyObject * obj1 = 0 ;
24744 char *kwnames[] = {
24745 (char *) "win",(char *) "onlyIfNeeded", NULL
24746 };
24747
24748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24749 if (obj0) {
24750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24751 if (SWIG_arg_fail(1)) SWIG_fail;
24752 }
24753 if (obj1) {
24754 {
24755 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24756 if (SWIG_arg_fail(2)) SWIG_fail;
24757 }
24758 }
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 result = (bool)wxSafeYield(arg1,arg2);
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 {
24767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24768 }
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj = NULL;
24777 char *kwnames[] = {
24778 NULL
24779 };
24780
24781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24782 {
24783 PyThreadState* __tstate = wxPyBeginAllowThreads();
24784 wxWakeUpIdle();
24785
24786 wxPyEndAllowThreads(__tstate);
24787 if (PyErr_Occurred()) SWIG_fail;
24788 }
24789 Py_INCREF(Py_None); resultobj = Py_None;
24790 return resultobj;
24791 fail:
24792 return NULL;
24793 }
24794
24795
24796 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24797 PyObject *resultobj = NULL;
24798 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24799 wxEvent *arg2 = 0 ;
24800 PyObject * obj0 = 0 ;
24801 PyObject * obj1 = 0 ;
24802 char *kwnames[] = {
24803 (char *) "dest",(char *) "event", NULL
24804 };
24805
24806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24808 if (SWIG_arg_fail(1)) SWIG_fail;
24809 {
24810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24811 if (SWIG_arg_fail(2)) SWIG_fail;
24812 if (arg2 == NULL) {
24813 SWIG_null_ref("wxEvent");
24814 }
24815 if (SWIG_arg_fail(2)) SWIG_fail;
24816 }
24817 {
24818 PyThreadState* __tstate = wxPyBeginAllowThreads();
24819 wxPostEvent(arg1,*arg2);
24820
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 Py_INCREF(Py_None); resultobj = Py_None;
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj = NULL;
24833 char *kwnames[] = {
24834 NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24838 {
24839 PyThreadState* __tstate = wxPyBeginAllowThreads();
24840 wxApp_CleanUp();
24841
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 Py_INCREF(Py_None); resultobj = Py_None;
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj = NULL;
24854 wxPyApp *result;
24855 char *kwnames[] = {
24856 NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24860 {
24861 PyThreadState* __tstate = wxPyBeginAllowThreads();
24862 result = (wxPyApp *)wxPyGetApp();
24863
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 {
24868 resultobj = wxPyMake_wxObject(result, 0);
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24877 PyObject *resultobj = NULL;
24878 char *arg1 = (char *) 0 ;
24879 PyObject * obj0 = 0 ;
24880 char *kwnames[] = {
24881 (char *) "encoding", NULL
24882 };
24883
24884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24885 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24886 SWIG_arg_fail(1);SWIG_fail;
24887 }
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 wxSetDefaultPyEncoding((char const *)arg1);
24891
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 Py_INCREF(Py_None); resultobj = Py_None;
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24903 PyObject *resultobj = NULL;
24904 char *result;
24905 char *kwnames[] = {
24906 NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24910 {
24911 PyThreadState* __tstate = wxPyBeginAllowThreads();
24912 result = (char *)wxGetDefaultPyEncoding();
24913
24914 wxPyEndAllowThreads(__tstate);
24915 if (PyErr_Occurred()) SWIG_fail;
24916 }
24917 resultobj = SWIG_FromCharPtr(result);
24918 return resultobj;
24919 fail:
24920 return NULL;
24921 }
24922
24923
24924 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24925 PyObject *resultobj = NULL;
24926 wxEventLoop *result;
24927 char *kwnames[] = {
24928 NULL
24929 };
24930
24931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (wxEventLoop *)new wxEventLoop();
24935
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj = NULL;
24948 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24949 PyObject * obj0 = 0 ;
24950 char *kwnames[] = {
24951 (char *) "self", NULL
24952 };
24953
24954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24956 if (SWIG_arg_fail(1)) SWIG_fail;
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 delete arg1;
24960
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 Py_INCREF(Py_None); resultobj = Py_None;
24965 return resultobj;
24966 fail:
24967 return NULL;
24968 }
24969
24970
24971 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24972 PyObject *resultobj = NULL;
24973 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24974 int result;
24975 PyObject * obj0 = 0 ;
24976 char *kwnames[] = {
24977 (char *) "self", NULL
24978 };
24979
24980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24982 if (SWIG_arg_fail(1)) SWIG_fail;
24983 {
24984 PyThreadState* __tstate = wxPyBeginAllowThreads();
24985 result = (int)(arg1)->Run();
24986
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 {
24991 resultobj = SWIG_From_int(static_cast<int >(result));
24992 }
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25000 PyObject *resultobj = NULL;
25001 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25002 int arg2 = (int) 0 ;
25003 PyObject * obj0 = 0 ;
25004 PyObject * obj1 = 0 ;
25005 char *kwnames[] = {
25006 (char *) "self",(char *) "rc", NULL
25007 };
25008
25009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25011 if (SWIG_arg_fail(1)) SWIG_fail;
25012 if (obj1) {
25013 {
25014 arg2 = static_cast<int >(SWIG_As_int(obj1));
25015 if (SWIG_arg_fail(2)) SWIG_fail;
25016 }
25017 }
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 (arg1)->Exit(arg2);
25021
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 Py_INCREF(Py_None); resultobj = Py_None;
25026 return resultobj;
25027 fail:
25028 return NULL;
25029 }
25030
25031
25032 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25033 PyObject *resultobj = NULL;
25034 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25035 bool result;
25036 PyObject * obj0 = 0 ;
25037 char *kwnames[] = {
25038 (char *) "self", NULL
25039 };
25040
25041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25043 if (SWIG_arg_fail(1)) SWIG_fail;
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = (bool)((wxEventLoop const *)arg1)->Pending();
25047
25048 wxPyEndAllowThreads(__tstate);
25049 if (PyErr_Occurred()) SWIG_fail;
25050 }
25051 {
25052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25053 }
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25061 PyObject *resultobj = NULL;
25062 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25063 bool result;
25064 PyObject * obj0 = 0 ;
25065 char *kwnames[] = {
25066 (char *) "self", NULL
25067 };
25068
25069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25071 if (SWIG_arg_fail(1)) SWIG_fail;
25072 {
25073 PyThreadState* __tstate = wxPyBeginAllowThreads();
25074 result = (bool)(arg1)->Dispatch();
25075
25076 wxPyEndAllowThreads(__tstate);
25077 if (PyErr_Occurred()) SWIG_fail;
25078 }
25079 {
25080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25081 }
25082 return resultobj;
25083 fail:
25084 return NULL;
25085 }
25086
25087
25088 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25089 PyObject *resultobj = NULL;
25090 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25091 bool result;
25092 PyObject * obj0 = 0 ;
25093 char *kwnames[] = {
25094 (char *) "self", NULL
25095 };
25096
25097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25099 if (SWIG_arg_fail(1)) SWIG_fail;
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25103
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 {
25108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25109 }
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25117 PyObject *resultobj = NULL;
25118 wxEventLoop *result;
25119 char *kwnames[] = {
25120 NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (wxEventLoop *)wxEventLoop::GetActive();
25127
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj = NULL;
25140 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25141 PyObject * obj0 = 0 ;
25142 char *kwnames[] = {
25143 (char *) "loop", NULL
25144 };
25145
25146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25148 if (SWIG_arg_fail(1)) SWIG_fail;
25149 {
25150 PyThreadState* __tstate = wxPyBeginAllowThreads();
25151 wxEventLoop::SetActive(arg1);
25152
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 Py_INCREF(Py_None); resultobj = Py_None;
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25164 PyObject *obj;
25165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25166 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25167 Py_INCREF(obj);
25168 return Py_BuildValue((char *)"");
25169 }
25170 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj = NULL;
25172 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25173 wxEventLoopActivator *result;
25174 PyObject * obj0 = 0 ;
25175 char *kwnames[] = {
25176 (char *) "evtLoop", NULL
25177 };
25178
25179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25181 if (SWIG_arg_fail(1)) SWIG_fail;
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj = NULL;
25198 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25199 PyObject * obj0 = 0 ;
25200 char *kwnames[] = {
25201 (char *) "self", NULL
25202 };
25203
25204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 delete arg1;
25210
25211 wxPyEndAllowThreads(__tstate);
25212 if (PyErr_Occurred()) SWIG_fail;
25213 }
25214 Py_INCREF(Py_None); resultobj = Py_None;
25215 return resultobj;
25216 fail:
25217 return NULL;
25218 }
25219
25220
25221 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25222 PyObject *obj;
25223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25224 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25225 Py_INCREF(obj);
25226 return Py_BuildValue((char *)"");
25227 }
25228 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj = NULL;
25230 int arg1 = (int) 0 ;
25231 int arg2 = (int) 0 ;
25232 int arg3 = (int) 0 ;
25233 wxAcceleratorEntry *result;
25234 PyObject * obj0 = 0 ;
25235 PyObject * obj1 = 0 ;
25236 PyObject * obj2 = 0 ;
25237 char *kwnames[] = {
25238 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25242 if (obj0) {
25243 {
25244 arg1 = static_cast<int >(SWIG_As_int(obj0));
25245 if (SWIG_arg_fail(1)) SWIG_fail;
25246 }
25247 }
25248 if (obj1) {
25249 {
25250 arg2 = static_cast<int >(SWIG_As_int(obj1));
25251 if (SWIG_arg_fail(2)) SWIG_fail;
25252 }
25253 }
25254 if (obj2) {
25255 {
25256 arg3 = static_cast<int >(SWIG_As_int(obj2));
25257 if (SWIG_arg_fail(3)) SWIG_fail;
25258 }
25259 }
25260 {
25261 PyThreadState* __tstate = wxPyBeginAllowThreads();
25262 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25263
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25268 return resultobj;
25269 fail:
25270 return NULL;
25271 }
25272
25273
25274 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25275 PyObject *resultobj = NULL;
25276 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25277 PyObject * obj0 = 0 ;
25278 char *kwnames[] = {
25279 (char *) "self", NULL
25280 };
25281
25282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25284 if (SWIG_arg_fail(1)) SWIG_fail;
25285 {
25286 PyThreadState* __tstate = wxPyBeginAllowThreads();
25287 delete arg1;
25288
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 Py_INCREF(Py_None); resultobj = Py_None;
25293 return resultobj;
25294 fail:
25295 return NULL;
25296 }
25297
25298
25299 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25300 PyObject *resultobj = NULL;
25301 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25302 int arg2 ;
25303 int arg3 ;
25304 int arg4 ;
25305 PyObject * obj0 = 0 ;
25306 PyObject * obj1 = 0 ;
25307 PyObject * obj2 = 0 ;
25308 PyObject * obj3 = 0 ;
25309 char *kwnames[] = {
25310 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25311 };
25312
25313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25315 if (SWIG_arg_fail(1)) SWIG_fail;
25316 {
25317 arg2 = static_cast<int >(SWIG_As_int(obj1));
25318 if (SWIG_arg_fail(2)) SWIG_fail;
25319 }
25320 {
25321 arg3 = static_cast<int >(SWIG_As_int(obj2));
25322 if (SWIG_arg_fail(3)) SWIG_fail;
25323 }
25324 {
25325 arg4 = static_cast<int >(SWIG_As_int(obj3));
25326 if (SWIG_arg_fail(4)) SWIG_fail;
25327 }
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 (arg1)->Set(arg2,arg3,arg4);
25331
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 Py_INCREF(Py_None); resultobj = Py_None;
25336 return resultobj;
25337 fail:
25338 return NULL;
25339 }
25340
25341
25342 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25343 PyObject *resultobj = NULL;
25344 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25345 int result;
25346 PyObject * obj0 = 0 ;
25347 char *kwnames[] = {
25348 (char *) "self", NULL
25349 };
25350
25351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25353 if (SWIG_arg_fail(1)) SWIG_fail;
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 result = (int)(arg1)->GetFlags();
25357
25358 wxPyEndAllowThreads(__tstate);
25359 if (PyErr_Occurred()) SWIG_fail;
25360 }
25361 {
25362 resultobj = SWIG_From_int(static_cast<int >(result));
25363 }
25364 return resultobj;
25365 fail:
25366 return NULL;
25367 }
25368
25369
25370 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25371 PyObject *resultobj = NULL;
25372 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25373 int result;
25374 PyObject * obj0 = 0 ;
25375 char *kwnames[] = {
25376 (char *) "self", NULL
25377 };
25378
25379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25381 if (SWIG_arg_fail(1)) SWIG_fail;
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (int)(arg1)->GetKeyCode();
25385
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 {
25390 resultobj = SWIG_From_int(static_cast<int >(result));
25391 }
25392 return resultobj;
25393 fail:
25394 return NULL;
25395 }
25396
25397
25398 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25399 PyObject *resultobj = NULL;
25400 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25401 int result;
25402 PyObject * obj0 = 0 ;
25403 char *kwnames[] = {
25404 (char *) "self", NULL
25405 };
25406
25407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25409 if (SWIG_arg_fail(1)) SWIG_fail;
25410 {
25411 PyThreadState* __tstate = wxPyBeginAllowThreads();
25412 result = (int)(arg1)->GetCommand();
25413
25414 wxPyEndAllowThreads(__tstate);
25415 if (PyErr_Occurred()) SWIG_fail;
25416 }
25417 {
25418 resultobj = SWIG_From_int(static_cast<int >(result));
25419 }
25420 return resultobj;
25421 fail:
25422 return NULL;
25423 }
25424
25425
25426 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25427 PyObject *obj;
25428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25429 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25430 Py_INCREF(obj);
25431 return Py_BuildValue((char *)"");
25432 }
25433 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj = NULL;
25435 int arg1 ;
25436 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25437 wxAcceleratorTable *result;
25438 PyObject * obj0 = 0 ;
25439 char *kwnames[] = {
25440 (char *) "n", NULL
25441 };
25442
25443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25444 {
25445 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25446 if (arg2) arg1 = PyList_Size(obj0);
25447 else arg1 = 0;
25448 }
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25452
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25457 {
25458 delete [] arg2;
25459 }
25460 return resultobj;
25461 fail:
25462 {
25463 delete [] arg2;
25464 }
25465 return NULL;
25466 }
25467
25468
25469 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25470 PyObject *resultobj = NULL;
25471 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25472 PyObject * obj0 = 0 ;
25473 char *kwnames[] = {
25474 (char *) "self", NULL
25475 };
25476
25477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25479 if (SWIG_arg_fail(1)) SWIG_fail;
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 delete arg1;
25483
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 Py_INCREF(Py_None); resultobj = Py_None;
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25495 PyObject *resultobj = NULL;
25496 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25497 bool result;
25498 PyObject * obj0 = 0 ;
25499 char *kwnames[] = {
25500 (char *) "self", NULL
25501 };
25502
25503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25505 if (SWIG_arg_fail(1)) SWIG_fail;
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 {
25514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25515 }
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25523 PyObject *obj;
25524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25525 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25526 Py_INCREF(obj);
25527 return Py_BuildValue((char *)"");
25528 }
25529 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25530 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25531 return 1;
25532 }
25533
25534
25535 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25536 PyObject *pyobj = NULL;
25537
25538 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25539 return pyobj;
25540 }
25541
25542
25543 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj = NULL;
25545 wxString *arg1 = 0 ;
25546 wxAcceleratorEntry *result;
25547 bool temp1 = false ;
25548 PyObject * obj0 = 0 ;
25549 char *kwnames[] = {
25550 (char *) "label", NULL
25551 };
25552
25553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25554 {
25555 arg1 = wxString_in_helper(obj0);
25556 if (arg1 == NULL) SWIG_fail;
25557 temp1 = true;
25558 }
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25562
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25567 {
25568 if (temp1)
25569 delete arg1;
25570 }
25571 return resultobj;
25572 fail:
25573 {
25574 if (temp1)
25575 delete arg1;
25576 }
25577 return NULL;
25578 }
25579
25580
25581 static int _wrap_PanelNameStr_set(PyObject *) {
25582 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25583 return 1;
25584 }
25585
25586
25587 static PyObject *_wrap_PanelNameStr_get(void) {
25588 PyObject *pyobj = NULL;
25589
25590 {
25591 #if wxUSE_UNICODE
25592 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25593 #else
25594 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25595 #endif
25596 }
25597 return pyobj;
25598 }
25599
25600
25601 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25602 PyObject *resultobj = NULL;
25603 wxVisualAttributes *result;
25604 char *kwnames[] = {
25605 NULL
25606 };
25607
25608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25609 {
25610 PyThreadState* __tstate = wxPyBeginAllowThreads();
25611 result = (wxVisualAttributes *)new_wxVisualAttributes();
25612
25613 wxPyEndAllowThreads(__tstate);
25614 if (PyErr_Occurred()) SWIG_fail;
25615 }
25616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25624 PyObject *resultobj = NULL;
25625 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25626 PyObject * obj0 = 0 ;
25627 char *kwnames[] = {
25628 (char *) "self", NULL
25629 };
25630
25631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25633 if (SWIG_arg_fail(1)) SWIG_fail;
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 delete_wxVisualAttributes(arg1);
25637
25638 wxPyEndAllowThreads(__tstate);
25639 if (PyErr_Occurred()) SWIG_fail;
25640 }
25641 Py_INCREF(Py_None); resultobj = Py_None;
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25649 PyObject *resultobj = NULL;
25650 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25651 wxFont *arg2 = (wxFont *) 0 ;
25652 PyObject * obj0 = 0 ;
25653 PyObject * obj1 = 0 ;
25654 char *kwnames[] = {
25655 (char *) "self",(char *) "font", NULL
25656 };
25657
25658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25660 if (SWIG_arg_fail(1)) SWIG_fail;
25661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25662 if (SWIG_arg_fail(2)) SWIG_fail;
25663 if (arg1) (arg1)->font = *arg2;
25664
25665 Py_INCREF(Py_None); resultobj = Py_None;
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj = NULL;
25674 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25675 wxFont *result;
25676 PyObject * obj0 = 0 ;
25677 char *kwnames[] = {
25678 (char *) "self", NULL
25679 };
25680
25681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25683 if (SWIG_arg_fail(1)) SWIG_fail;
25684 result = (wxFont *)& ((arg1)->font);
25685
25686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25694 PyObject *resultobj = NULL;
25695 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25696 wxColour *arg2 = (wxColour *) 0 ;
25697 PyObject * obj0 = 0 ;
25698 PyObject * obj1 = 0 ;
25699 char *kwnames[] = {
25700 (char *) "self",(char *) "colFg", NULL
25701 };
25702
25703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25705 if (SWIG_arg_fail(1)) SWIG_fail;
25706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(2)) SWIG_fail;
25708 if (arg1) (arg1)->colFg = *arg2;
25709
25710 Py_INCREF(Py_None); resultobj = Py_None;
25711 return resultobj;
25712 fail:
25713 return NULL;
25714 }
25715
25716
25717 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25718 PyObject *resultobj = NULL;
25719 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25720 wxColour *result;
25721 PyObject * obj0 = 0 ;
25722 char *kwnames[] = {
25723 (char *) "self", NULL
25724 };
25725
25726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25728 if (SWIG_arg_fail(1)) SWIG_fail;
25729 result = (wxColour *)& ((arg1)->colFg);
25730
25731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25739 PyObject *resultobj = NULL;
25740 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25741 wxColour *arg2 = (wxColour *) 0 ;
25742 PyObject * obj0 = 0 ;
25743 PyObject * obj1 = 0 ;
25744 char *kwnames[] = {
25745 (char *) "self",(char *) "colBg", NULL
25746 };
25747
25748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25750 if (SWIG_arg_fail(1)) SWIG_fail;
25751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25752 if (SWIG_arg_fail(2)) SWIG_fail;
25753 if (arg1) (arg1)->colBg = *arg2;
25754
25755 Py_INCREF(Py_None); resultobj = Py_None;
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25763 PyObject *resultobj = NULL;
25764 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25765 wxColour *result;
25766 PyObject * obj0 = 0 ;
25767 char *kwnames[] = {
25768 (char *) "self", NULL
25769 };
25770
25771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25773 if (SWIG_arg_fail(1)) SWIG_fail;
25774 result = (wxColour *)& ((arg1)->colBg);
25775
25776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25784 PyObject *obj;
25785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25786 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25787 Py_INCREF(obj);
25788 return Py_BuildValue((char *)"");
25789 }
25790 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25791 PyObject *resultobj = NULL;
25792 wxWindow *arg1 = (wxWindow *) 0 ;
25793 int arg2 = (int) (int)-1 ;
25794 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25795 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25796 wxSize const &arg4_defvalue = wxDefaultSize ;
25797 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25798 long arg5 = (long) 0 ;
25799 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25800 wxString *arg6 = (wxString *) &arg6_defvalue ;
25801 wxWindow *result;
25802 wxPoint temp3 ;
25803 wxSize temp4 ;
25804 bool temp6 = false ;
25805 PyObject * obj0 = 0 ;
25806 PyObject * obj1 = 0 ;
25807 PyObject * obj2 = 0 ;
25808 PyObject * obj3 = 0 ;
25809 PyObject * obj4 = 0 ;
25810 PyObject * obj5 = 0 ;
25811 char *kwnames[] = {
25812 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25813 };
25814
25815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25817 if (SWIG_arg_fail(1)) SWIG_fail;
25818 if (obj1) {
25819 {
25820 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25821 if (SWIG_arg_fail(2)) SWIG_fail;
25822 }
25823 }
25824 if (obj2) {
25825 {
25826 arg3 = &temp3;
25827 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25828 }
25829 }
25830 if (obj3) {
25831 {
25832 arg4 = &temp4;
25833 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25834 }
25835 }
25836 if (obj4) {
25837 {
25838 arg5 = static_cast<long >(SWIG_As_long(obj4));
25839 if (SWIG_arg_fail(5)) SWIG_fail;
25840 }
25841 }
25842 if (obj5) {
25843 {
25844 arg6 = wxString_in_helper(obj5);
25845 if (arg6 == NULL) SWIG_fail;
25846 temp6 = true;
25847 }
25848 }
25849 {
25850 if (!wxPyCheckForApp()) SWIG_fail;
25851 PyThreadState* __tstate = wxPyBeginAllowThreads();
25852 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25853
25854 wxPyEndAllowThreads(__tstate);
25855 if (PyErr_Occurred()) SWIG_fail;
25856 }
25857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25858 {
25859 if (temp6)
25860 delete arg6;
25861 }
25862 return resultobj;
25863 fail:
25864 {
25865 if (temp6)
25866 delete arg6;
25867 }
25868 return NULL;
25869 }
25870
25871
25872 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = NULL;
25874 wxWindow *result;
25875 char *kwnames[] = {
25876 NULL
25877 };
25878
25879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25880 {
25881 if (!wxPyCheckForApp()) SWIG_fail;
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 result = (wxWindow *)new wxWindow();
25884
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = NULL;
25897 wxWindow *arg1 = (wxWindow *) 0 ;
25898 wxWindow *arg2 = (wxWindow *) 0 ;
25899 int arg3 = (int) (int)-1 ;
25900 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25901 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25902 wxSize const &arg5_defvalue = wxDefaultSize ;
25903 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25904 long arg6 = (long) 0 ;
25905 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25906 wxString *arg7 = (wxString *) &arg7_defvalue ;
25907 bool result;
25908 wxPoint temp4 ;
25909 wxSize temp5 ;
25910 bool temp7 = false ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 PyObject * obj2 = 0 ;
25914 PyObject * obj3 = 0 ;
25915 PyObject * obj4 = 0 ;
25916 PyObject * obj5 = 0 ;
25917 PyObject * obj6 = 0 ;
25918 char *kwnames[] = {
25919 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25920 };
25921
25922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25924 if (SWIG_arg_fail(1)) SWIG_fail;
25925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25926 if (SWIG_arg_fail(2)) SWIG_fail;
25927 if (obj2) {
25928 {
25929 arg3 = static_cast<int const >(SWIG_As_int(obj2));
25930 if (SWIG_arg_fail(3)) SWIG_fail;
25931 }
25932 }
25933 if (obj3) {
25934 {
25935 arg4 = &temp4;
25936 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25937 }
25938 }
25939 if (obj4) {
25940 {
25941 arg5 = &temp5;
25942 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25943 }
25944 }
25945 if (obj5) {
25946 {
25947 arg6 = static_cast<long >(SWIG_As_long(obj5));
25948 if (SWIG_arg_fail(6)) SWIG_fail;
25949 }
25950 }
25951 if (obj6) {
25952 {
25953 arg7 = wxString_in_helper(obj6);
25954 if (arg7 == NULL) SWIG_fail;
25955 temp7 = true;
25956 }
25957 }
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25961
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 {
25966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25967 }
25968 {
25969 if (temp7)
25970 delete arg7;
25971 }
25972 return resultobj;
25973 fail:
25974 {
25975 if (temp7)
25976 delete arg7;
25977 }
25978 return NULL;
25979 }
25980
25981
25982 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj = NULL;
25984 wxWindow *arg1 = (wxWindow *) 0 ;
25985 bool arg2 = (bool) false ;
25986 bool result;
25987 PyObject * obj0 = 0 ;
25988 PyObject * obj1 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self",(char *) "force", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 if (obj1) {
25997 {
25998 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
25999 if (SWIG_arg_fail(2)) SWIG_fail;
26000 }
26001 }
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 result = (bool)(arg1)->Close(arg2);
26005
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 {
26010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26011 }
26012 return resultobj;
26013 fail:
26014 return NULL;
26015 }
26016
26017
26018 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26019 PyObject *resultobj = NULL;
26020 wxWindow *arg1 = (wxWindow *) 0 ;
26021 bool result;
26022 PyObject * obj0 = 0 ;
26023 char *kwnames[] = {
26024 (char *) "self", NULL
26025 };
26026
26027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26029 if (SWIG_arg_fail(1)) SWIG_fail;
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (bool)(arg1)->Destroy();
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 {
26038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26039 }
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj = NULL;
26048 wxWindow *arg1 = (wxWindow *) 0 ;
26049 bool result;
26050 PyObject * obj0 = 0 ;
26051 char *kwnames[] = {
26052 (char *) "self", NULL
26053 };
26054
26055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26057 if (SWIG_arg_fail(1)) SWIG_fail;
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 result = (bool)(arg1)->DestroyChildren();
26061
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 {
26066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26067 }
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj = NULL;
26076 wxWindow *arg1 = (wxWindow *) 0 ;
26077 bool result;
26078 PyObject * obj0 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26089
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26095 }
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26103 PyObject *resultobj = NULL;
26104 wxWindow *arg1 = (wxWindow *) 0 ;
26105 wxString *arg2 = 0 ;
26106 bool temp2 = false ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self",(char *) "label", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 arg2 = wxString_in_helper(obj1);
26118 if (arg2 == NULL) SWIG_fail;
26119 temp2 = true;
26120 }
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 (arg1)->SetLabel((wxString const &)*arg2);
26124
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 Py_INCREF(Py_None); resultobj = Py_None;
26129 {
26130 if (temp2)
26131 delete arg2;
26132 }
26133 return resultobj;
26134 fail:
26135 {
26136 if (temp2)
26137 delete arg2;
26138 }
26139 return NULL;
26140 }
26141
26142
26143 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26144 PyObject *resultobj = NULL;
26145 wxWindow *arg1 = (wxWindow *) 0 ;
26146 wxString result;
26147 PyObject * obj0 = 0 ;
26148 char *kwnames[] = {
26149 (char *) "self", NULL
26150 };
26151
26152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26154 if (SWIG_arg_fail(1)) SWIG_fail;
26155 {
26156 PyThreadState* __tstate = wxPyBeginAllowThreads();
26157 result = ((wxWindow const *)arg1)->GetLabel();
26158
26159 wxPyEndAllowThreads(__tstate);
26160 if (PyErr_Occurred()) SWIG_fail;
26161 }
26162 {
26163 #if wxUSE_UNICODE
26164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26165 #else
26166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26167 #endif
26168 }
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26176 PyObject *resultobj = NULL;
26177 wxWindow *arg1 = (wxWindow *) 0 ;
26178 wxString *arg2 = 0 ;
26179 bool temp2 = false ;
26180 PyObject * obj0 = 0 ;
26181 PyObject * obj1 = 0 ;
26182 char *kwnames[] = {
26183 (char *) "self",(char *) "name", NULL
26184 };
26185
26186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26188 if (SWIG_arg_fail(1)) SWIG_fail;
26189 {
26190 arg2 = wxString_in_helper(obj1);
26191 if (arg2 == NULL) SWIG_fail;
26192 temp2 = true;
26193 }
26194 {
26195 PyThreadState* __tstate = wxPyBeginAllowThreads();
26196 (arg1)->SetName((wxString const &)*arg2);
26197
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 Py_INCREF(Py_None); resultobj = Py_None;
26202 {
26203 if (temp2)
26204 delete arg2;
26205 }
26206 return resultobj;
26207 fail:
26208 {
26209 if (temp2)
26210 delete arg2;
26211 }
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj = NULL;
26218 wxWindow *arg1 = (wxWindow *) 0 ;
26219 wxString result;
26220 PyObject * obj0 = 0 ;
26221 char *kwnames[] = {
26222 (char *) "self", NULL
26223 };
26224
26225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26227 if (SWIG_arg_fail(1)) SWIG_fail;
26228 {
26229 PyThreadState* __tstate = wxPyBeginAllowThreads();
26230 result = ((wxWindow const *)arg1)->GetName();
26231
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 {
26236 #if wxUSE_UNICODE
26237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26238 #else
26239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26240 #endif
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj = NULL;
26250 wxWindow *arg1 = (wxWindow *) 0 ;
26251 wxWindowVariant arg2 ;
26252 PyObject * obj0 = 0 ;
26253 PyObject * obj1 = 0 ;
26254 char *kwnames[] = {
26255 (char *) "self",(char *) "variant", NULL
26256 };
26257
26258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26260 if (SWIG_arg_fail(1)) SWIG_fail;
26261 {
26262 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26263 if (SWIG_arg_fail(2)) SWIG_fail;
26264 }
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 (arg1)->SetWindowVariant(arg2);
26268
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 Py_INCREF(Py_None); resultobj = Py_None;
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26280 PyObject *resultobj = NULL;
26281 wxWindow *arg1 = (wxWindow *) 0 ;
26282 wxWindowVariant result;
26283 PyObject * obj0 = 0 ;
26284 char *kwnames[] = {
26285 (char *) "self", NULL
26286 };
26287
26288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26290 if (SWIG_arg_fail(1)) SWIG_fail;
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26294
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_From_int((result));
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj = NULL;
26307 wxWindow *arg1 = (wxWindow *) 0 ;
26308 int arg2 ;
26309 PyObject * obj0 = 0 ;
26310 PyObject * obj1 = 0 ;
26311 char *kwnames[] = {
26312 (char *) "self",(char *) "winid", NULL
26313 };
26314
26315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26317 if (SWIG_arg_fail(1)) SWIG_fail;
26318 {
26319 arg2 = static_cast<int >(SWIG_As_int(obj1));
26320 if (SWIG_arg_fail(2)) SWIG_fail;
26321 }
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 (arg1)->SetId(arg2);
26325
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 Py_INCREF(Py_None); resultobj = Py_None;
26330 return resultobj;
26331 fail:
26332 return NULL;
26333 }
26334
26335
26336 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26337 PyObject *resultobj = NULL;
26338 wxWindow *arg1 = (wxWindow *) 0 ;
26339 int result;
26340 PyObject * obj0 = 0 ;
26341 char *kwnames[] = {
26342 (char *) "self", NULL
26343 };
26344
26345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26347 if (SWIG_arg_fail(1)) SWIG_fail;
26348 {
26349 PyThreadState* __tstate = wxPyBeginAllowThreads();
26350 result = (int)((wxWindow const *)arg1)->GetId();
26351
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 {
26356 resultobj = SWIG_From_int(static_cast<int >(result));
26357 }
26358 return resultobj;
26359 fail:
26360 return NULL;
26361 }
26362
26363
26364 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26365 PyObject *resultobj = NULL;
26366 int result;
26367 char *kwnames[] = {
26368 NULL
26369 };
26370
26371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 result = (int)wxWindow::NewControlId();
26375
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 {
26380 resultobj = SWIG_From_int(static_cast<int >(result));
26381 }
26382 return resultobj;
26383 fail:
26384 return NULL;
26385 }
26386
26387
26388 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = NULL;
26390 int arg1 ;
26391 int result;
26392 PyObject * obj0 = 0 ;
26393 char *kwnames[] = {
26394 (char *) "winid", NULL
26395 };
26396
26397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26398 {
26399 arg1 = static_cast<int >(SWIG_As_int(obj0));
26400 if (SWIG_arg_fail(1)) SWIG_fail;
26401 }
26402 {
26403 PyThreadState* __tstate = wxPyBeginAllowThreads();
26404 result = (int)wxWindow::NextControlId(arg1);
26405
26406 wxPyEndAllowThreads(__tstate);
26407 if (PyErr_Occurred()) SWIG_fail;
26408 }
26409 {
26410 resultobj = SWIG_From_int(static_cast<int >(result));
26411 }
26412 return resultobj;
26413 fail:
26414 return NULL;
26415 }
26416
26417
26418 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26419 PyObject *resultobj = NULL;
26420 int arg1 ;
26421 int result;
26422 PyObject * obj0 = 0 ;
26423 char *kwnames[] = {
26424 (char *) "winid", NULL
26425 };
26426
26427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26428 {
26429 arg1 = static_cast<int >(SWIG_As_int(obj0));
26430 if (SWIG_arg_fail(1)) SWIG_fail;
26431 }
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 result = (int)wxWindow::PrevControlId(arg1);
26435
26436 wxPyEndAllowThreads(__tstate);
26437 if (PyErr_Occurred()) SWIG_fail;
26438 }
26439 {
26440 resultobj = SWIG_From_int(static_cast<int >(result));
26441 }
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26449 PyObject *resultobj = NULL;
26450 wxWindow *arg1 = (wxWindow *) 0 ;
26451 wxSize *arg2 = 0 ;
26452 wxSize temp2 ;
26453 PyObject * obj0 = 0 ;
26454 PyObject * obj1 = 0 ;
26455 char *kwnames[] = {
26456 (char *) "self",(char *) "size", NULL
26457 };
26458
26459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26461 if (SWIG_arg_fail(1)) SWIG_fail;
26462 {
26463 arg2 = &temp2;
26464 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26465 }
26466 {
26467 PyThreadState* __tstate = wxPyBeginAllowThreads();
26468 (arg1)->SetSize((wxSize const &)*arg2);
26469
26470 wxPyEndAllowThreads(__tstate);
26471 if (PyErr_Occurred()) SWIG_fail;
26472 }
26473 Py_INCREF(Py_None); resultobj = Py_None;
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj = NULL;
26482 wxWindow *arg1 = (wxWindow *) 0 ;
26483 int arg2 ;
26484 int arg3 ;
26485 int arg4 ;
26486 int arg5 ;
26487 int arg6 = (int) wxSIZE_AUTO ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 PyObject * obj2 = 0 ;
26491 PyObject * obj3 = 0 ;
26492 PyObject * obj4 = 0 ;
26493 PyObject * obj5 = 0 ;
26494 char *kwnames[] = {
26495 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26496 };
26497
26498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26500 if (SWIG_arg_fail(1)) SWIG_fail;
26501 {
26502 arg2 = static_cast<int >(SWIG_As_int(obj1));
26503 if (SWIG_arg_fail(2)) SWIG_fail;
26504 }
26505 {
26506 arg3 = static_cast<int >(SWIG_As_int(obj2));
26507 if (SWIG_arg_fail(3)) SWIG_fail;
26508 }
26509 {
26510 arg4 = static_cast<int >(SWIG_As_int(obj3));
26511 if (SWIG_arg_fail(4)) SWIG_fail;
26512 }
26513 {
26514 arg5 = static_cast<int >(SWIG_As_int(obj4));
26515 if (SWIG_arg_fail(5)) SWIG_fail;
26516 }
26517 if (obj5) {
26518 {
26519 arg6 = static_cast<int >(SWIG_As_int(obj5));
26520 if (SWIG_arg_fail(6)) SWIG_fail;
26521 }
26522 }
26523 {
26524 PyThreadState* __tstate = wxPyBeginAllowThreads();
26525 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26526
26527 wxPyEndAllowThreads(__tstate);
26528 if (PyErr_Occurred()) SWIG_fail;
26529 }
26530 Py_INCREF(Py_None); resultobj = Py_None;
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26538 PyObject *resultobj = NULL;
26539 wxWindow *arg1 = (wxWindow *) 0 ;
26540 wxRect *arg2 = 0 ;
26541 int arg3 = (int) wxSIZE_AUTO ;
26542 wxRect temp2 ;
26543 PyObject * obj0 = 0 ;
26544 PyObject * obj1 = 0 ;
26545 PyObject * obj2 = 0 ;
26546 char *kwnames[] = {
26547 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26548 };
26549
26550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26552 if (SWIG_arg_fail(1)) SWIG_fail;
26553 {
26554 arg2 = &temp2;
26555 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26556 }
26557 if (obj2) {
26558 {
26559 arg3 = static_cast<int >(SWIG_As_int(obj2));
26560 if (SWIG_arg_fail(3)) SWIG_fail;
26561 }
26562 }
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26566
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 Py_INCREF(Py_None); resultobj = Py_None;
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj = NULL;
26579 wxWindow *arg1 = (wxWindow *) 0 ;
26580 int arg2 ;
26581 int arg3 ;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584 PyObject * obj2 = 0 ;
26585 char *kwnames[] = {
26586 (char *) "self",(char *) "width",(char *) "height", NULL
26587 };
26588
26589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26591 if (SWIG_arg_fail(1)) SWIG_fail;
26592 {
26593 arg2 = static_cast<int >(SWIG_As_int(obj1));
26594 if (SWIG_arg_fail(2)) SWIG_fail;
26595 }
26596 {
26597 arg3 = static_cast<int >(SWIG_As_int(obj2));
26598 if (SWIG_arg_fail(3)) SWIG_fail;
26599 }
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 (arg1)->SetSize(arg2,arg3);
26603
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 Py_INCREF(Py_None); resultobj = Py_None;
26608 return resultobj;
26609 fail:
26610 return NULL;
26611 }
26612
26613
26614 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26615 PyObject *resultobj = NULL;
26616 wxWindow *arg1 = (wxWindow *) 0 ;
26617 wxPoint *arg2 = 0 ;
26618 int arg3 = (int) wxSIZE_USE_EXISTING ;
26619 wxPoint temp2 ;
26620 PyObject * obj0 = 0 ;
26621 PyObject * obj1 = 0 ;
26622 PyObject * obj2 = 0 ;
26623 char *kwnames[] = {
26624 (char *) "self",(char *) "pt",(char *) "flags", NULL
26625 };
26626
26627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26629 if (SWIG_arg_fail(1)) SWIG_fail;
26630 {
26631 arg2 = &temp2;
26632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26633 }
26634 if (obj2) {
26635 {
26636 arg3 = static_cast<int >(SWIG_As_int(obj2));
26637 if (SWIG_arg_fail(3)) SWIG_fail;
26638 }
26639 }
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 (arg1)->Move((wxPoint const &)*arg2,arg3);
26643
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 Py_INCREF(Py_None); resultobj = Py_None;
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26655 PyObject *resultobj = NULL;
26656 wxWindow *arg1 = (wxWindow *) 0 ;
26657 int arg2 ;
26658 int arg3 ;
26659 int arg4 = (int) wxSIZE_USE_EXISTING ;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662 PyObject * obj2 = 0 ;
26663 PyObject * obj3 = 0 ;
26664 char *kwnames[] = {
26665 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26666 };
26667
26668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 {
26672 arg2 = static_cast<int >(SWIG_As_int(obj1));
26673 if (SWIG_arg_fail(2)) SWIG_fail;
26674 }
26675 {
26676 arg3 = static_cast<int >(SWIG_As_int(obj2));
26677 if (SWIG_arg_fail(3)) SWIG_fail;
26678 }
26679 if (obj3) {
26680 {
26681 arg4 = static_cast<int >(SWIG_As_int(obj3));
26682 if (SWIG_arg_fail(4)) SWIG_fail;
26683 }
26684 }
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 (arg1)->Move(arg2,arg3,arg4);
26688
26689 wxPyEndAllowThreads(__tstate);
26690 if (PyErr_Occurred()) SWIG_fail;
26691 }
26692 Py_INCREF(Py_None); resultobj = Py_None;
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj = NULL;
26701 wxWindow *arg1 = (wxWindow *) 0 ;
26702 wxSize const &arg2_defvalue = wxDefaultSize ;
26703 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26704 wxSize temp2 ;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707 char *kwnames[] = {
26708 (char *) "self",(char *) "size", NULL
26709 };
26710
26711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26713 if (SWIG_arg_fail(1)) SWIG_fail;
26714 if (obj1) {
26715 {
26716 arg2 = &temp2;
26717 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26718 }
26719 }
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 Py_INCREF(Py_None); resultobj = Py_None;
26728 return resultobj;
26729 fail:
26730 return NULL;
26731 }
26732
26733
26734 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26735 PyObject *resultobj = NULL;
26736 wxWindow *arg1 = (wxWindow *) 0 ;
26737 PyObject * obj0 = 0 ;
26738 char *kwnames[] = {
26739 (char *) "self", NULL
26740 };
26741
26742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26744 if (SWIG_arg_fail(1)) SWIG_fail;
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 (arg1)->Raise();
26748
26749 wxPyEndAllowThreads(__tstate);
26750 if (PyErr_Occurred()) SWIG_fail;
26751 }
26752 Py_INCREF(Py_None); resultobj = Py_None;
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = NULL;
26761 wxWindow *arg1 = (wxWindow *) 0 ;
26762 PyObject * obj0 = 0 ;
26763 char *kwnames[] = {
26764 (char *) "self", NULL
26765 };
26766
26767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26769 if (SWIG_arg_fail(1)) SWIG_fail;
26770 {
26771 PyThreadState* __tstate = wxPyBeginAllowThreads();
26772 (arg1)->Lower();
26773
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 Py_INCREF(Py_None); resultobj = Py_None;
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj = NULL;
26786 wxWindow *arg1 = (wxWindow *) 0 ;
26787 wxSize *arg2 = 0 ;
26788 wxSize temp2 ;
26789 PyObject * obj0 = 0 ;
26790 PyObject * obj1 = 0 ;
26791 char *kwnames[] = {
26792 (char *) "self",(char *) "size", NULL
26793 };
26794
26795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26797 if (SWIG_arg_fail(1)) SWIG_fail;
26798 {
26799 arg2 = &temp2;
26800 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26801 }
26802 {
26803 PyThreadState* __tstate = wxPyBeginAllowThreads();
26804 (arg1)->SetClientSize((wxSize const &)*arg2);
26805
26806 wxPyEndAllowThreads(__tstate);
26807 if (PyErr_Occurred()) SWIG_fail;
26808 }
26809 Py_INCREF(Py_None); resultobj = Py_None;
26810 return resultobj;
26811 fail:
26812 return NULL;
26813 }
26814
26815
26816 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26817 PyObject *resultobj = NULL;
26818 wxWindow *arg1 = (wxWindow *) 0 ;
26819 int arg2 ;
26820 int arg3 ;
26821 PyObject * obj0 = 0 ;
26822 PyObject * obj1 = 0 ;
26823 PyObject * obj2 = 0 ;
26824 char *kwnames[] = {
26825 (char *) "self",(char *) "width",(char *) "height", NULL
26826 };
26827
26828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26830 if (SWIG_arg_fail(1)) SWIG_fail;
26831 {
26832 arg2 = static_cast<int >(SWIG_As_int(obj1));
26833 if (SWIG_arg_fail(2)) SWIG_fail;
26834 }
26835 {
26836 arg3 = static_cast<int >(SWIG_As_int(obj2));
26837 if (SWIG_arg_fail(3)) SWIG_fail;
26838 }
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 (arg1)->SetClientSize(arg2,arg3);
26842
26843 wxPyEndAllowThreads(__tstate);
26844 if (PyErr_Occurred()) SWIG_fail;
26845 }
26846 Py_INCREF(Py_None); resultobj = Py_None;
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = NULL;
26855 wxWindow *arg1 = (wxWindow *) 0 ;
26856 wxRect *arg2 = 0 ;
26857 wxRect temp2 ;
26858 PyObject * obj0 = 0 ;
26859 PyObject * obj1 = 0 ;
26860 char *kwnames[] = {
26861 (char *) "self",(char *) "rect", NULL
26862 };
26863
26864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26866 if (SWIG_arg_fail(1)) SWIG_fail;
26867 {
26868 arg2 = &temp2;
26869 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26870 }
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 (arg1)->SetClientSize((wxRect const &)*arg2);
26874
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 Py_INCREF(Py_None); resultobj = Py_None;
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26886 PyObject *resultobj = NULL;
26887 wxWindow *arg1 = (wxWindow *) 0 ;
26888 wxPoint result;
26889 PyObject * obj0 = 0 ;
26890 char *kwnames[] = {
26891 (char *) "self", NULL
26892 };
26893
26894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26896 if (SWIG_arg_fail(1)) SWIG_fail;
26897 {
26898 PyThreadState* __tstate = wxPyBeginAllowThreads();
26899 result = (arg1)->GetPosition();
26900
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 {
26905 wxPoint * resultptr;
26906 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26908 }
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26916 PyObject *resultobj = NULL;
26917 wxWindow *arg1 = (wxWindow *) 0 ;
26918 int *arg2 = (int *) 0 ;
26919 int *arg3 = (int *) 0 ;
26920 int temp2 ;
26921 int res2 = 0 ;
26922 int temp3 ;
26923 int res3 = 0 ;
26924 PyObject * obj0 = 0 ;
26925 char *kwnames[] = {
26926 (char *) "self", NULL
26927 };
26928
26929 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26930 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26933 if (SWIG_arg_fail(1)) SWIG_fail;
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 (arg1)->GetPosition(arg2,arg3);
26937
26938 wxPyEndAllowThreads(__tstate);
26939 if (PyErr_Occurred()) SWIG_fail;
26940 }
26941 Py_INCREF(Py_None); resultobj = Py_None;
26942 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26943 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26944 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26945 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26946 return resultobj;
26947 fail:
26948 return NULL;
26949 }
26950
26951
26952 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26953 PyObject *resultobj = NULL;
26954 wxWindow *arg1 = (wxWindow *) 0 ;
26955 wxSize result;
26956 PyObject * obj0 = 0 ;
26957 char *kwnames[] = {
26958 (char *) "self", NULL
26959 };
26960
26961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26963 if (SWIG_arg_fail(1)) SWIG_fail;
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 result = ((wxWindow const *)arg1)->GetSize();
26967
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 {
26972 wxSize * resultptr;
26973 resultptr = new wxSize(static_cast<wxSize & >(result));
26974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26975 }
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26983 PyObject *resultobj = NULL;
26984 wxWindow *arg1 = (wxWindow *) 0 ;
26985 int *arg2 = (int *) 0 ;
26986 int *arg3 = (int *) 0 ;
26987 int temp2 ;
26988 int res2 = 0 ;
26989 int temp3 ;
26990 int res3 = 0 ;
26991 PyObject * obj0 = 0 ;
26992 char *kwnames[] = {
26993 (char *) "self", NULL
26994 };
26995
26996 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26997 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 Py_INCREF(Py_None); resultobj = Py_None;
27009 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27010 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27011 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27012 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj = NULL;
27021 wxWindow *arg1 = (wxWindow *) 0 ;
27022 wxRect result;
27023 PyObject * obj0 = 0 ;
27024 char *kwnames[] = {
27025 (char *) "self", NULL
27026 };
27027
27028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27030 if (SWIG_arg_fail(1)) SWIG_fail;
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 result = ((wxWindow const *)arg1)->GetRect();
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 {
27039 wxRect * resultptr;
27040 resultptr = new wxRect(static_cast<wxRect & >(result));
27041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27042 }
27043 return resultobj;
27044 fail:
27045 return NULL;
27046 }
27047
27048
27049 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27050 PyObject *resultobj = NULL;
27051 wxWindow *arg1 = (wxWindow *) 0 ;
27052 wxSize result;
27053 PyObject * obj0 = 0 ;
27054 char *kwnames[] = {
27055 (char *) "self", NULL
27056 };
27057
27058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27060 if (SWIG_arg_fail(1)) SWIG_fail;
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = ((wxWindow const *)arg1)->GetClientSize();
27064
27065 wxPyEndAllowThreads(__tstate);
27066 if (PyErr_Occurred()) SWIG_fail;
27067 }
27068 {
27069 wxSize * resultptr;
27070 resultptr = new wxSize(static_cast<wxSize & >(result));
27071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27072 }
27073 return resultobj;
27074 fail:
27075 return NULL;
27076 }
27077
27078
27079 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27080 PyObject *resultobj = NULL;
27081 wxWindow *arg1 = (wxWindow *) 0 ;
27082 int *arg2 = (int *) 0 ;
27083 int *arg3 = (int *) 0 ;
27084 int temp2 ;
27085 int res2 = 0 ;
27086 int temp3 ;
27087 int res3 = 0 ;
27088 PyObject * obj0 = 0 ;
27089 char *kwnames[] = {
27090 (char *) "self", NULL
27091 };
27092
27093 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27094 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27097 if (SWIG_arg_fail(1)) SWIG_fail;
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27101
27102 wxPyEndAllowThreads(__tstate);
27103 if (PyErr_Occurred()) SWIG_fail;
27104 }
27105 Py_INCREF(Py_None); resultobj = Py_None;
27106 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27107 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27108 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27109 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj = NULL;
27118 wxWindow *arg1 = (wxWindow *) 0 ;
27119 wxPoint result;
27120 PyObject * obj0 = 0 ;
27121 char *kwnames[] = {
27122 (char *) "self", NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(1)) SWIG_fail;
27128 {
27129 PyThreadState* __tstate = wxPyBeginAllowThreads();
27130 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27131
27132 wxPyEndAllowThreads(__tstate);
27133 if (PyErr_Occurred()) SWIG_fail;
27134 }
27135 {
27136 wxPoint * resultptr;
27137 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27139 }
27140 return resultobj;
27141 fail:
27142 return NULL;
27143 }
27144
27145
27146 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27147 PyObject *resultobj = NULL;
27148 wxWindow *arg1 = (wxWindow *) 0 ;
27149 wxRect result;
27150 PyObject * obj0 = 0 ;
27151 char *kwnames[] = {
27152 (char *) "self", NULL
27153 };
27154
27155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27157 if (SWIG_arg_fail(1)) SWIG_fail;
27158 {
27159 PyThreadState* __tstate = wxPyBeginAllowThreads();
27160 result = ((wxWindow const *)arg1)->GetClientRect();
27161
27162 wxPyEndAllowThreads(__tstate);
27163 if (PyErr_Occurred()) SWIG_fail;
27164 }
27165 {
27166 wxRect * resultptr;
27167 resultptr = new wxRect(static_cast<wxRect & >(result));
27168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27169 }
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj = NULL;
27178 wxWindow *arg1 = (wxWindow *) 0 ;
27179 wxSize result;
27180 PyObject * obj0 = 0 ;
27181 char *kwnames[] = {
27182 (char *) "self", NULL
27183 };
27184
27185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(1)) SWIG_fail;
27188 {
27189 PyThreadState* __tstate = wxPyBeginAllowThreads();
27190 result = ((wxWindow const *)arg1)->GetBestSize();
27191
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 wxSize * resultptr;
27197 resultptr = new wxSize(static_cast<wxSize & >(result));
27198 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27207 PyObject *resultobj = NULL;
27208 wxWindow *arg1 = (wxWindow *) 0 ;
27209 int *arg2 = (int *) 0 ;
27210 int *arg3 = (int *) 0 ;
27211 int temp2 ;
27212 int res2 = 0 ;
27213 int temp3 ;
27214 int res3 = 0 ;
27215 PyObject * obj0 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self", NULL
27218 };
27219
27220 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27221 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27224 if (SWIG_arg_fail(1)) SWIG_fail;
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27228
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 Py_INCREF(Py_None); resultobj = Py_None;
27233 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27234 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27235 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27236 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27237 return resultobj;
27238 fail:
27239 return NULL;
27240 }
27241
27242
27243 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27244 PyObject *resultobj = NULL;
27245 wxWindow *arg1 = (wxWindow *) 0 ;
27246 PyObject * obj0 = 0 ;
27247 char *kwnames[] = {
27248 (char *) "self", NULL
27249 };
27250
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27253 if (SWIG_arg_fail(1)) SWIG_fail;
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 (arg1)->InvalidateBestSize();
27257
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 Py_INCREF(Py_None); resultobj = Py_None;
27262 return resultobj;
27263 fail:
27264 return NULL;
27265 }
27266
27267
27268 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27269 PyObject *resultobj = NULL;
27270 wxWindow *arg1 = (wxWindow *) 0 ;
27271 wxSize *arg2 = 0 ;
27272 wxSize temp2 ;
27273 PyObject * obj0 = 0 ;
27274 PyObject * obj1 = 0 ;
27275 char *kwnames[] = {
27276 (char *) "self",(char *) "size", NULL
27277 };
27278
27279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27281 if (SWIG_arg_fail(1)) SWIG_fail;
27282 {
27283 arg2 = &temp2;
27284 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27285 }
27286 {
27287 PyThreadState* __tstate = wxPyBeginAllowThreads();
27288 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27289
27290 wxPyEndAllowThreads(__tstate);
27291 if (PyErr_Occurred()) SWIG_fail;
27292 }
27293 Py_INCREF(Py_None); resultobj = Py_None;
27294 return resultobj;
27295 fail:
27296 return NULL;
27297 }
27298
27299
27300 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27301 PyObject *resultobj = NULL;
27302 wxWindow *arg1 = (wxWindow *) 0 ;
27303 wxSize result;
27304 PyObject * obj0 = 0 ;
27305 char *kwnames[] = {
27306 (char *) "self", NULL
27307 };
27308
27309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27311 if (SWIG_arg_fail(1)) SWIG_fail;
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27315
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 {
27320 wxSize * resultptr;
27321 resultptr = new wxSize(static_cast<wxSize & >(result));
27322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27323 }
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27331 PyObject *resultobj = NULL;
27332 wxWindow *arg1 = (wxWindow *) 0 ;
27333 wxSize result;
27334 PyObject * obj0 = 0 ;
27335 char *kwnames[] = {
27336 (char *) "self", NULL
27337 };
27338
27339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27341 if (SWIG_arg_fail(1)) SWIG_fail;
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27345
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 {
27350 wxSize * resultptr;
27351 resultptr = new wxSize(static_cast<wxSize & >(result));
27352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27353 }
27354 return resultobj;
27355 fail:
27356 return NULL;
27357 }
27358
27359
27360 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27361 PyObject *resultobj = NULL;
27362 wxWindow *arg1 = (wxWindow *) 0 ;
27363 int arg2 = (int) wxBOTH ;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self",(char *) "direction", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 if (obj1) {
27374 {
27375 arg2 = static_cast<int >(SWIG_As_int(obj1));
27376 if (SWIG_arg_fail(2)) SWIG_fail;
27377 }
27378 }
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 (arg1)->Center(arg2);
27382
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 Py_INCREF(Py_None); resultobj = Py_None;
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27394 PyObject *resultobj = NULL;
27395 wxWindow *arg1 = (wxWindow *) 0 ;
27396 int arg2 = (int) wxBOTH ;
27397 PyObject * obj0 = 0 ;
27398 PyObject * obj1 = 0 ;
27399 char *kwnames[] = {
27400 (char *) "self",(char *) "dir", NULL
27401 };
27402
27403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27405 if (SWIG_arg_fail(1)) SWIG_fail;
27406 if (obj1) {
27407 {
27408 arg2 = static_cast<int >(SWIG_As_int(obj1));
27409 if (SWIG_arg_fail(2)) SWIG_fail;
27410 }
27411 }
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 (arg1)->CenterOnScreen(arg2);
27415
27416 wxPyEndAllowThreads(__tstate);
27417 if (PyErr_Occurred()) SWIG_fail;
27418 }
27419 Py_INCREF(Py_None); resultobj = Py_None;
27420 return resultobj;
27421 fail:
27422 return NULL;
27423 }
27424
27425
27426 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27427 PyObject *resultobj = NULL;
27428 wxWindow *arg1 = (wxWindow *) 0 ;
27429 int arg2 = (int) wxBOTH ;
27430 PyObject * obj0 = 0 ;
27431 PyObject * obj1 = 0 ;
27432 char *kwnames[] = {
27433 (char *) "self",(char *) "dir", NULL
27434 };
27435
27436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27438 if (SWIG_arg_fail(1)) SWIG_fail;
27439 if (obj1) {
27440 {
27441 arg2 = static_cast<int >(SWIG_As_int(obj1));
27442 if (SWIG_arg_fail(2)) SWIG_fail;
27443 }
27444 }
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 (arg1)->CenterOnParent(arg2);
27448
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 Py_INCREF(Py_None); resultobj = Py_None;
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27460 PyObject *resultobj = NULL;
27461 wxWindow *arg1 = (wxWindow *) 0 ;
27462 PyObject * obj0 = 0 ;
27463 char *kwnames[] = {
27464 (char *) "self", NULL
27465 };
27466
27467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27469 if (SWIG_arg_fail(1)) SWIG_fail;
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 (arg1)->Fit();
27473
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 Py_INCREF(Py_None); resultobj = Py_None;
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27485 PyObject *resultobj = NULL;
27486 wxWindow *arg1 = (wxWindow *) 0 ;
27487 PyObject * obj0 = 0 ;
27488 char *kwnames[] = {
27489 (char *) "self", NULL
27490 };
27491
27492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27494 if (SWIG_arg_fail(1)) SWIG_fail;
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 (arg1)->FitInside();
27498
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 Py_INCREF(Py_None); resultobj = Py_None;
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27510 PyObject *resultobj = NULL;
27511 wxWindow *arg1 = (wxWindow *) 0 ;
27512 int arg2 ;
27513 int arg3 ;
27514 int arg4 = (int) -1 ;
27515 int arg5 = (int) -1 ;
27516 int arg6 = (int) -1 ;
27517 int arg7 = (int) -1 ;
27518 PyObject * obj0 = 0 ;
27519 PyObject * obj1 = 0 ;
27520 PyObject * obj2 = 0 ;
27521 PyObject * obj3 = 0 ;
27522 PyObject * obj4 = 0 ;
27523 PyObject * obj5 = 0 ;
27524 PyObject * obj6 = 0 ;
27525 char *kwnames[] = {
27526 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27527 };
27528
27529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27531 if (SWIG_arg_fail(1)) SWIG_fail;
27532 {
27533 arg2 = static_cast<int >(SWIG_As_int(obj1));
27534 if (SWIG_arg_fail(2)) SWIG_fail;
27535 }
27536 {
27537 arg3 = static_cast<int >(SWIG_As_int(obj2));
27538 if (SWIG_arg_fail(3)) SWIG_fail;
27539 }
27540 if (obj3) {
27541 {
27542 arg4 = static_cast<int >(SWIG_As_int(obj3));
27543 if (SWIG_arg_fail(4)) SWIG_fail;
27544 }
27545 }
27546 if (obj4) {
27547 {
27548 arg5 = static_cast<int >(SWIG_As_int(obj4));
27549 if (SWIG_arg_fail(5)) SWIG_fail;
27550 }
27551 }
27552 if (obj5) {
27553 {
27554 arg6 = static_cast<int >(SWIG_As_int(obj5));
27555 if (SWIG_arg_fail(6)) SWIG_fail;
27556 }
27557 }
27558 if (obj6) {
27559 {
27560 arg7 = static_cast<int >(SWIG_As_int(obj6));
27561 if (SWIG_arg_fail(7)) SWIG_fail;
27562 }
27563 }
27564 {
27565 PyThreadState* __tstate = wxPyBeginAllowThreads();
27566 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27567
27568 wxPyEndAllowThreads(__tstate);
27569 if (PyErr_Occurred()) SWIG_fail;
27570 }
27571 Py_INCREF(Py_None); resultobj = Py_None;
27572 return resultobj;
27573 fail:
27574 return NULL;
27575 }
27576
27577
27578 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj = NULL;
27580 wxWindow *arg1 = (wxWindow *) 0 ;
27581 wxSize *arg2 = 0 ;
27582 wxSize const &arg3_defvalue = wxDefaultSize ;
27583 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27584 wxSize const &arg4_defvalue = wxDefaultSize ;
27585 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27586 wxSize temp2 ;
27587 wxSize temp3 ;
27588 wxSize temp4 ;
27589 PyObject * obj0 = 0 ;
27590 PyObject * obj1 = 0 ;
27591 PyObject * obj2 = 0 ;
27592 PyObject * obj3 = 0 ;
27593 char *kwnames[] = {
27594 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27595 };
27596
27597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27599 if (SWIG_arg_fail(1)) SWIG_fail;
27600 {
27601 arg2 = &temp2;
27602 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27603 }
27604 if (obj2) {
27605 {
27606 arg3 = &temp3;
27607 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27608 }
27609 }
27610 if (obj3) {
27611 {
27612 arg4 = &temp4;
27613 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27614 }
27615 }
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 Py_INCREF(Py_None); resultobj = Py_None;
27624 return resultobj;
27625 fail:
27626 return NULL;
27627 }
27628
27629
27630 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj = NULL;
27632 wxWindow *arg1 = (wxWindow *) 0 ;
27633 int arg2 ;
27634 int arg3 ;
27635 int arg4 = (int) -1 ;
27636 int arg5 = (int) -1 ;
27637 PyObject * obj0 = 0 ;
27638 PyObject * obj1 = 0 ;
27639 PyObject * obj2 = 0 ;
27640 PyObject * obj3 = 0 ;
27641 PyObject * obj4 = 0 ;
27642 char *kwnames[] = {
27643 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27644 };
27645
27646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27648 if (SWIG_arg_fail(1)) SWIG_fail;
27649 {
27650 arg2 = static_cast<int >(SWIG_As_int(obj1));
27651 if (SWIG_arg_fail(2)) SWIG_fail;
27652 }
27653 {
27654 arg3 = static_cast<int >(SWIG_As_int(obj2));
27655 if (SWIG_arg_fail(3)) SWIG_fail;
27656 }
27657 if (obj3) {
27658 {
27659 arg4 = static_cast<int >(SWIG_As_int(obj3));
27660 if (SWIG_arg_fail(4)) SWIG_fail;
27661 }
27662 }
27663 if (obj4) {
27664 {
27665 arg5 = static_cast<int >(SWIG_As_int(obj4));
27666 if (SWIG_arg_fail(5)) SWIG_fail;
27667 }
27668 }
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 Py_INCREF(Py_None); resultobj = Py_None;
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27684 PyObject *resultobj = NULL;
27685 wxWindow *arg1 = (wxWindow *) 0 ;
27686 wxSize *arg2 = 0 ;
27687 wxSize const &arg3_defvalue = wxDefaultSize ;
27688 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27689 wxSize temp2 ;
27690 wxSize temp3 ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 PyObject * obj2 = 0 ;
27694 char *kwnames[] = {
27695 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27696 };
27697
27698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27700 if (SWIG_arg_fail(1)) SWIG_fail;
27701 {
27702 arg2 = &temp2;
27703 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27704 }
27705 if (obj2) {
27706 {
27707 arg3 = &temp3;
27708 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27709 }
27710 }
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 Py_INCREF(Py_None); resultobj = Py_None;
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj = NULL;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 wxSize result;
27729 PyObject * obj0 = 0 ;
27730 char *kwnames[] = {
27731 (char *) "self", NULL
27732 };
27733
27734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27736 if (SWIG_arg_fail(1)) SWIG_fail;
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = ((wxWindow const *)arg1)->GetMaxSize();
27740
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 {
27745 wxSize * resultptr;
27746 resultptr = new wxSize(static_cast<wxSize & >(result));
27747 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27748 }
27749 return resultobj;
27750 fail:
27751 return NULL;
27752 }
27753
27754
27755 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27756 PyObject *resultobj = NULL;
27757 wxWindow *arg1 = (wxWindow *) 0 ;
27758 wxSize result;
27759 PyObject * obj0 = 0 ;
27760 char *kwnames[] = {
27761 (char *) "self", NULL
27762 };
27763
27764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27766 if (SWIG_arg_fail(1)) SWIG_fail;
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = ((wxWindow const *)arg1)->GetMinSize();
27770
27771 wxPyEndAllowThreads(__tstate);
27772 if (PyErr_Occurred()) SWIG_fail;
27773 }
27774 {
27775 wxSize * resultptr;
27776 resultptr = new wxSize(static_cast<wxSize & >(result));
27777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27778 }
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj = NULL;
27787 wxWindow *arg1 = (wxWindow *) 0 ;
27788 wxSize *arg2 = 0 ;
27789 wxSize temp2 ;
27790 PyObject * obj0 = 0 ;
27791 PyObject * obj1 = 0 ;
27792 char *kwnames[] = {
27793 (char *) "self",(char *) "minSize", NULL
27794 };
27795
27796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27798 if (SWIG_arg_fail(1)) SWIG_fail;
27799 {
27800 arg2 = &temp2;
27801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27802 }
27803 {
27804 PyThreadState* __tstate = wxPyBeginAllowThreads();
27805 (arg1)->SetMinSize((wxSize const &)*arg2);
27806
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 Py_INCREF(Py_None); resultobj = Py_None;
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj = NULL;
27819 wxWindow *arg1 = (wxWindow *) 0 ;
27820 wxSize *arg2 = 0 ;
27821 wxSize temp2 ;
27822 PyObject * obj0 = 0 ;
27823 PyObject * obj1 = 0 ;
27824 char *kwnames[] = {
27825 (char *) "self",(char *) "maxSize", NULL
27826 };
27827
27828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27830 if (SWIG_arg_fail(1)) SWIG_fail;
27831 {
27832 arg2 = &temp2;
27833 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27834 }
27835 {
27836 PyThreadState* __tstate = wxPyBeginAllowThreads();
27837 (arg1)->SetMaxSize((wxSize const &)*arg2);
27838
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 Py_INCREF(Py_None); resultobj = Py_None;
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27850 PyObject *resultobj = NULL;
27851 wxWindow *arg1 = (wxWindow *) 0 ;
27852 int result;
27853 PyObject * obj0 = 0 ;
27854 char *kwnames[] = {
27855 (char *) "self", NULL
27856 };
27857
27858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27860 if (SWIG_arg_fail(1)) SWIG_fail;
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27864
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 {
27869 resultobj = SWIG_From_int(static_cast<int >(result));
27870 }
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27878 PyObject *resultobj = NULL;
27879 wxWindow *arg1 = (wxWindow *) 0 ;
27880 int result;
27881 PyObject * obj0 = 0 ;
27882 char *kwnames[] = {
27883 (char *) "self", NULL
27884 };
27885
27886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27888 if (SWIG_arg_fail(1)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = SWIG_From_int(static_cast<int >(result));
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj = NULL;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 int result;
27909 PyObject * obj0 = 0 ;
27910 char *kwnames[] = {
27911 (char *) "self", NULL
27912 };
27913
27914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27920
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 resultobj = SWIG_From_int(static_cast<int >(result));
27926 }
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj = NULL;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 int result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = SWIG_From_int(static_cast<int >(result));
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj = NULL;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 wxSize *arg2 = 0 ;
27965 wxSize temp2 ;
27966 PyObject * obj0 = 0 ;
27967 PyObject * obj1 = 0 ;
27968 char *kwnames[] = {
27969 (char *) "self",(char *) "size", NULL
27970 };
27971
27972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27974 if (SWIG_arg_fail(1)) SWIG_fail;
27975 {
27976 arg2 = &temp2;
27977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27978 }
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27982
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 Py_INCREF(Py_None); resultobj = Py_None;
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj = NULL;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 int arg2 ;
27997 int arg3 ;
27998 PyObject * obj0 = 0 ;
27999 PyObject * obj1 = 0 ;
28000 PyObject * obj2 = 0 ;
28001 char *kwnames[] = {
28002 (char *) "self",(char *) "w",(char *) "h", NULL
28003 };
28004
28005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28007 if (SWIG_arg_fail(1)) SWIG_fail;
28008 {
28009 arg2 = static_cast<int >(SWIG_As_int(obj1));
28010 if (SWIG_arg_fail(2)) SWIG_fail;
28011 }
28012 {
28013 arg3 = static_cast<int >(SWIG_As_int(obj2));
28014 if (SWIG_arg_fail(3)) SWIG_fail;
28015 }
28016 {
28017 PyThreadState* __tstate = wxPyBeginAllowThreads();
28018 (arg1)->SetVirtualSize(arg2,arg3);
28019
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 Py_INCREF(Py_None); resultobj = Py_None;
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj = NULL;
28032 wxWindow *arg1 = (wxWindow *) 0 ;
28033 wxSize result;
28034 PyObject * obj0 = 0 ;
28035 char *kwnames[] = {
28036 (char *) "self", NULL
28037 };
28038
28039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28041 if (SWIG_arg_fail(1)) SWIG_fail;
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 result = ((wxWindow const *)arg1)->GetVirtualSize();
28045
28046 wxPyEndAllowThreads(__tstate);
28047 if (PyErr_Occurred()) SWIG_fail;
28048 }
28049 {
28050 wxSize * resultptr;
28051 resultptr = new wxSize(static_cast<wxSize & >(result));
28052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28053 }
28054 return resultobj;
28055 fail:
28056 return NULL;
28057 }
28058
28059
28060 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28061 PyObject *resultobj = NULL;
28062 wxWindow *arg1 = (wxWindow *) 0 ;
28063 int *arg2 = (int *) 0 ;
28064 int *arg3 = (int *) 0 ;
28065 int temp2 ;
28066 int res2 = 0 ;
28067 int temp3 ;
28068 int res3 = 0 ;
28069 PyObject * obj0 = 0 ;
28070 char *kwnames[] = {
28071 (char *) "self", NULL
28072 };
28073
28074 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28075 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28078 if (SWIG_arg_fail(1)) SWIG_fail;
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28082
28083 wxPyEndAllowThreads(__tstate);
28084 if (PyErr_Occurred()) SWIG_fail;
28085 }
28086 Py_INCREF(Py_None); resultobj = Py_None;
28087 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28088 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28089 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28090 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28098 PyObject *resultobj = NULL;
28099 wxWindow *arg1 = (wxWindow *) 0 ;
28100 wxSize result;
28101 PyObject * obj0 = 0 ;
28102 char *kwnames[] = {
28103 (char *) "self", NULL
28104 };
28105
28106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28108 if (SWIG_arg_fail(1)) SWIG_fail;
28109 {
28110 PyThreadState* __tstate = wxPyBeginAllowThreads();
28111 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28112
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 {
28117 wxSize * resultptr;
28118 resultptr = new wxSize(static_cast<wxSize & >(result));
28119 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28120 }
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj = NULL;
28129 wxWindow *arg1 = (wxWindow *) 0 ;
28130 bool arg2 = (bool) true ;
28131 bool result;
28132 PyObject * obj0 = 0 ;
28133 PyObject * obj1 = 0 ;
28134 char *kwnames[] = {
28135 (char *) "self",(char *) "show", NULL
28136 };
28137
28138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28140 if (SWIG_arg_fail(1)) SWIG_fail;
28141 if (obj1) {
28142 {
28143 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28144 if (SWIG_arg_fail(2)) SWIG_fail;
28145 }
28146 }
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (bool)(arg1)->Show(arg2);
28150
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 {
28155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28156 }
28157 return resultobj;
28158 fail:
28159 return NULL;
28160 }
28161
28162
28163 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28164 PyObject *resultobj = NULL;
28165 wxWindow *arg1 = (wxWindow *) 0 ;
28166 bool result;
28167 PyObject * obj0 = 0 ;
28168 char *kwnames[] = {
28169 (char *) "self", NULL
28170 };
28171
28172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28174 if (SWIG_arg_fail(1)) SWIG_fail;
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = (bool)(arg1)->Hide();
28178
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 {
28183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28184 }
28185 return resultobj;
28186 fail:
28187 return NULL;
28188 }
28189
28190
28191 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28192 PyObject *resultobj = NULL;
28193 wxWindow *arg1 = (wxWindow *) 0 ;
28194 bool arg2 = (bool) true ;
28195 bool result;
28196 PyObject * obj0 = 0 ;
28197 PyObject * obj1 = 0 ;
28198 char *kwnames[] = {
28199 (char *) "self",(char *) "enable", NULL
28200 };
28201
28202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28204 if (SWIG_arg_fail(1)) SWIG_fail;
28205 if (obj1) {
28206 {
28207 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28208 if (SWIG_arg_fail(2)) SWIG_fail;
28209 }
28210 }
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (bool)(arg1)->Enable(arg2);
28214
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 {
28219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28220 }
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28228 PyObject *resultobj = NULL;
28229 wxWindow *arg1 = (wxWindow *) 0 ;
28230 bool result;
28231 PyObject * obj0 = 0 ;
28232 char *kwnames[] = {
28233 (char *) "self", NULL
28234 };
28235
28236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28238 if (SWIG_arg_fail(1)) SWIG_fail;
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (bool)(arg1)->Disable();
28242
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 {
28247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28248 }
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28256 PyObject *resultobj = NULL;
28257 wxWindow *arg1 = (wxWindow *) 0 ;
28258 bool result;
28259 PyObject * obj0 = 0 ;
28260 char *kwnames[] = {
28261 (char *) "self", NULL
28262 };
28263
28264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28266 if (SWIG_arg_fail(1)) SWIG_fail;
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (bool)((wxWindow const *)arg1)->IsShown();
28270
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 {
28275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28276 }
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28284 PyObject *resultobj = NULL;
28285 wxWindow *arg1 = (wxWindow *) 0 ;
28286 bool result;
28287 PyObject * obj0 = 0 ;
28288 char *kwnames[] = {
28289 (char *) "self", NULL
28290 };
28291
28292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28294 if (SWIG_arg_fail(1)) SWIG_fail;
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28298
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 {
28303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28304 }
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28312 PyObject *resultobj = NULL;
28313 wxWindow *arg1 = (wxWindow *) 0 ;
28314 long arg2 ;
28315 PyObject * obj0 = 0 ;
28316 PyObject * obj1 = 0 ;
28317 char *kwnames[] = {
28318 (char *) "self",(char *) "style", NULL
28319 };
28320
28321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28323 if (SWIG_arg_fail(1)) SWIG_fail;
28324 {
28325 arg2 = static_cast<long >(SWIG_As_long(obj1));
28326 if (SWIG_arg_fail(2)) SWIG_fail;
28327 }
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 (arg1)->SetWindowStyleFlag(arg2);
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 Py_INCREF(Py_None); resultobj = Py_None;
28336 return resultobj;
28337 fail:
28338 return NULL;
28339 }
28340
28341
28342 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28343 PyObject *resultobj = NULL;
28344 wxWindow *arg1 = (wxWindow *) 0 ;
28345 long result;
28346 PyObject * obj0 = 0 ;
28347 char *kwnames[] = {
28348 (char *) "self", NULL
28349 };
28350
28351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28353 if (SWIG_arg_fail(1)) SWIG_fail;
28354 {
28355 PyThreadState* __tstate = wxPyBeginAllowThreads();
28356 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28357
28358 wxPyEndAllowThreads(__tstate);
28359 if (PyErr_Occurred()) SWIG_fail;
28360 }
28361 {
28362 resultobj = SWIG_From_long(static_cast<long >(result));
28363 }
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28371 PyObject *resultobj = NULL;
28372 wxWindow *arg1 = (wxWindow *) 0 ;
28373 int arg2 ;
28374 bool result;
28375 PyObject * obj0 = 0 ;
28376 PyObject * obj1 = 0 ;
28377 char *kwnames[] = {
28378 (char *) "self",(char *) "flag", NULL
28379 };
28380
28381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28383 if (SWIG_arg_fail(1)) SWIG_fail;
28384 {
28385 arg2 = static_cast<int >(SWIG_As_int(obj1));
28386 if (SWIG_arg_fail(2)) SWIG_fail;
28387 }
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28391
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 {
28396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28397 }
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj = NULL;
28406 wxWindow *arg1 = (wxWindow *) 0 ;
28407 bool result;
28408 PyObject * obj0 = 0 ;
28409 char *kwnames[] = {
28410 (char *) "self", NULL
28411 };
28412
28413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28415 if (SWIG_arg_fail(1)) SWIG_fail;
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)((wxWindow const *)arg1)->IsRetained();
28419
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 {
28424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28425 }
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj = NULL;
28434 wxWindow *arg1 = (wxWindow *) 0 ;
28435 long arg2 ;
28436 PyObject * obj0 = 0 ;
28437 PyObject * obj1 = 0 ;
28438 char *kwnames[] = {
28439 (char *) "self",(char *) "exStyle", NULL
28440 };
28441
28442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28444 if (SWIG_arg_fail(1)) SWIG_fail;
28445 {
28446 arg2 = static_cast<long >(SWIG_As_long(obj1));
28447 if (SWIG_arg_fail(2)) SWIG_fail;
28448 }
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 (arg1)->SetExtraStyle(arg2);
28452
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 Py_INCREF(Py_None); resultobj = Py_None;
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj = NULL;
28465 wxWindow *arg1 = (wxWindow *) 0 ;
28466 long result;
28467 PyObject * obj0 = 0 ;
28468 char *kwnames[] = {
28469 (char *) "self", NULL
28470 };
28471
28472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28474 if (SWIG_arg_fail(1)) SWIG_fail;
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 {
28483 resultobj = SWIG_From_long(static_cast<long >(result));
28484 }
28485 return resultobj;
28486 fail:
28487 return NULL;
28488 }
28489
28490
28491 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj = NULL;
28493 wxWindow *arg1 = (wxWindow *) 0 ;
28494 bool arg2 = (bool) true ;
28495 PyObject * obj0 = 0 ;
28496 PyObject * obj1 = 0 ;
28497 char *kwnames[] = {
28498 (char *) "self",(char *) "modal", NULL
28499 };
28500
28501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28503 if (SWIG_arg_fail(1)) SWIG_fail;
28504 if (obj1) {
28505 {
28506 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28507 if (SWIG_arg_fail(2)) SWIG_fail;
28508 }
28509 }
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 (arg1)->MakeModal(arg2);
28513
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 Py_INCREF(Py_None); resultobj = Py_None;
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28525 PyObject *resultobj = NULL;
28526 wxWindow *arg1 = (wxWindow *) 0 ;
28527 bool arg2 ;
28528 PyObject * obj0 = 0 ;
28529 PyObject * obj1 = 0 ;
28530 char *kwnames[] = {
28531 (char *) "self",(char *) "enableTheme", NULL
28532 };
28533
28534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28536 if (SWIG_arg_fail(1)) SWIG_fail;
28537 {
28538 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28539 if (SWIG_arg_fail(2)) SWIG_fail;
28540 }
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 (arg1)->SetThemeEnabled(arg2);
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 Py_INCREF(Py_None); resultobj = Py_None;
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28556 PyObject *resultobj = NULL;
28557 wxWindow *arg1 = (wxWindow *) 0 ;
28558 bool result;
28559 PyObject * obj0 = 0 ;
28560 char *kwnames[] = {
28561 (char *) "self", NULL
28562 };
28563
28564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28566 if (SWIG_arg_fail(1)) SWIG_fail;
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28570
28571 wxPyEndAllowThreads(__tstate);
28572 if (PyErr_Occurred()) SWIG_fail;
28573 }
28574 {
28575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28576 }
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj = NULL;
28585 wxWindow *arg1 = (wxWindow *) 0 ;
28586 PyObject * obj0 = 0 ;
28587 char *kwnames[] = {
28588 (char *) "self", NULL
28589 };
28590
28591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28593 if (SWIG_arg_fail(1)) SWIG_fail;
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 (arg1)->SetFocus();
28597
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 Py_INCREF(Py_None); resultobj = Py_None;
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28609 PyObject *resultobj = NULL;
28610 wxWindow *arg1 = (wxWindow *) 0 ;
28611 PyObject * obj0 = 0 ;
28612 char *kwnames[] = {
28613 (char *) "self", NULL
28614 };
28615
28616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28618 if (SWIG_arg_fail(1)) SWIG_fail;
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 (arg1)->SetFocusFromKbd();
28622
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 Py_INCREF(Py_None); resultobj = Py_None;
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj = NULL;
28635 wxWindow *result;
28636 char *kwnames[] = {
28637 NULL
28638 };
28639
28640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28641 {
28642 if (!wxPyCheckForApp()) SWIG_fail;
28643 PyThreadState* __tstate = wxPyBeginAllowThreads();
28644 result = (wxWindow *)wxWindow::FindFocus();
28645
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 {
28650 resultobj = wxPyMake_wxObject(result, 0);
28651 }
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28659 PyObject *resultobj = NULL;
28660 wxWindow *arg1 = (wxWindow *) 0 ;
28661 bool result;
28662 PyObject * obj0 = 0 ;
28663 char *kwnames[] = {
28664 (char *) "self", NULL
28665 };
28666
28667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28669 if (SWIG_arg_fail(1)) SWIG_fail;
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28673
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 {
28678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28679 }
28680 return resultobj;
28681 fail:
28682 return NULL;
28683 }
28684
28685
28686 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28687 PyObject *resultobj = NULL;
28688 wxWindow *arg1 = (wxWindow *) 0 ;
28689 bool result;
28690 PyObject * obj0 = 0 ;
28691 char *kwnames[] = {
28692 (char *) "self", NULL
28693 };
28694
28695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28697 if (SWIG_arg_fail(1)) SWIG_fail;
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28701
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 {
28706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28707 }
28708 return resultobj;
28709 fail:
28710 return NULL;
28711 }
28712
28713
28714 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28715 PyObject *resultobj = NULL;
28716 wxWindow *arg1 = (wxWindow *) 0 ;
28717 wxWindow *result;
28718 PyObject * obj0 = 0 ;
28719 char *kwnames[] = {
28720 (char *) "self", NULL
28721 };
28722
28723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28725 if (SWIG_arg_fail(1)) SWIG_fail;
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28729
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 {
28734 resultobj = wxPyMake_wxObject(result, 0);
28735 }
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = NULL;
28744 wxWindow *arg1 = (wxWindow *) 0 ;
28745 wxWindow *arg2 = (wxWindow *) 0 ;
28746 wxWindow *result;
28747 PyObject * obj0 = 0 ;
28748 PyObject * obj1 = 0 ;
28749 char *kwnames[] = {
28750 (char *) "self",(char *) "child", NULL
28751 };
28752
28753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28755 if (SWIG_arg_fail(1)) SWIG_fail;
28756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28757 if (SWIG_arg_fail(2)) SWIG_fail;
28758 {
28759 PyThreadState* __tstate = wxPyBeginAllowThreads();
28760 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28761
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 {
28766 resultobj = wxPyMake_wxObject(result, 0);
28767 }
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj = NULL;
28776 wxWindow *arg1 = (wxWindow *) 0 ;
28777 wxWindow *arg2 = (wxWindow *) 0 ;
28778 PyObject * obj0 = 0 ;
28779 PyObject * obj1 = 0 ;
28780 char *kwnames[] = {
28781 (char *) "self",(char *) "win", NULL
28782 };
28783
28784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28786 if (SWIG_arg_fail(1)) SWIG_fail;
28787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28788 if (SWIG_arg_fail(2)) SWIG_fail;
28789 {
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 (arg1)->SetTmpDefaultItem(arg2);
28792
28793 wxPyEndAllowThreads(__tstate);
28794 if (PyErr_Occurred()) SWIG_fail;
28795 }
28796 Py_INCREF(Py_None); resultobj = Py_None;
28797 return resultobj;
28798 fail:
28799 return NULL;
28800 }
28801
28802
28803 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28804 PyObject *resultobj = NULL;
28805 wxWindow *arg1 = (wxWindow *) 0 ;
28806 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28807 bool result;
28808 PyObject * obj0 = 0 ;
28809 PyObject * obj1 = 0 ;
28810 char *kwnames[] = {
28811 (char *) "self",(char *) "flags", NULL
28812 };
28813
28814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28816 if (SWIG_arg_fail(1)) SWIG_fail;
28817 if (obj1) {
28818 {
28819 arg2 = static_cast<int >(SWIG_As_int(obj1));
28820 if (SWIG_arg_fail(2)) SWIG_fail;
28821 }
28822 }
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = (bool)(arg1)->Navigate(arg2);
28826
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 {
28831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28832 }
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28840 PyObject *resultobj = NULL;
28841 wxWindow *arg1 = (wxWindow *) 0 ;
28842 wxWindow *arg2 = (wxWindow *) 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self",(char *) "win", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28853 if (SWIG_arg_fail(2)) SWIG_fail;
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 (arg1)->MoveAfterInTabOrder(arg2);
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 Py_INCREF(Py_None); resultobj = Py_None;
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28869 PyObject *resultobj = NULL;
28870 wxWindow *arg1 = (wxWindow *) 0 ;
28871 wxWindow *arg2 = (wxWindow *) 0 ;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 char *kwnames[] = {
28875 (char *) "self",(char *) "win", NULL
28876 };
28877
28878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28880 if (SWIG_arg_fail(1)) SWIG_fail;
28881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28882 if (SWIG_arg_fail(2)) SWIG_fail;
28883 {
28884 PyThreadState* __tstate = wxPyBeginAllowThreads();
28885 (arg1)->MoveBeforeInTabOrder(arg2);
28886
28887 wxPyEndAllowThreads(__tstate);
28888 if (PyErr_Occurred()) SWIG_fail;
28889 }
28890 Py_INCREF(Py_None); resultobj = Py_None;
28891 return resultobj;
28892 fail:
28893 return NULL;
28894 }
28895
28896
28897 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28898 PyObject *resultobj = NULL;
28899 wxWindow *arg1 = (wxWindow *) 0 ;
28900 PyObject *result;
28901 PyObject * obj0 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = (PyObject *)wxWindow_GetChildren(arg1);
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 resultobj = result;
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj = NULL;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 wxWindow *result;
28927 PyObject * obj0 = 0 ;
28928 char *kwnames[] = {
28929 (char *) "self", NULL
28930 };
28931
28932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28934 if (SWIG_arg_fail(1)) SWIG_fail;
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28938
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 {
28943 resultobj = wxPyMake_wxObject(result, 0);
28944 }
28945 return resultobj;
28946 fail:
28947 return NULL;
28948 }
28949
28950
28951 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj = NULL;
28953 wxWindow *arg1 = (wxWindow *) 0 ;
28954 wxWindow *result;
28955 PyObject * obj0 = 0 ;
28956 char *kwnames[] = {
28957 (char *) "self", NULL
28958 };
28959
28960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28962 if (SWIG_arg_fail(1)) SWIG_fail;
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 {
28971 resultobj = wxPyMake_wxObject(result, 0);
28972 }
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28980 PyObject *resultobj = NULL;
28981 wxWindow *arg1 = (wxWindow *) 0 ;
28982 bool result;
28983 PyObject * obj0 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28994
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 {
28999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29000 }
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj = NULL;
29009 wxWindow *arg1 = (wxWindow *) 0 ;
29010 wxWindow *arg2 = (wxWindow *) 0 ;
29011 bool result;
29012 PyObject * obj0 = 0 ;
29013 PyObject * obj1 = 0 ;
29014 char *kwnames[] = {
29015 (char *) "self",(char *) "newParent", NULL
29016 };
29017
29018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29020 if (SWIG_arg_fail(1)) SWIG_fail;
29021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29022 if (SWIG_arg_fail(2)) SWIG_fail;
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 result = (bool)(arg1)->Reparent(arg2);
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 {
29031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29032 }
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29040 PyObject *resultobj = NULL;
29041 wxWindow *arg1 = (wxWindow *) 0 ;
29042 wxWindow *arg2 = (wxWindow *) 0 ;
29043 PyObject * obj0 = 0 ;
29044 PyObject * obj1 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "child", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29053 if (SWIG_arg_fail(2)) SWIG_fail;
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 (arg1)->AddChild(arg2);
29057
29058 wxPyEndAllowThreads(__tstate);
29059 if (PyErr_Occurred()) SWIG_fail;
29060 }
29061 Py_INCREF(Py_None); resultobj = Py_None;
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29069 PyObject *resultobj = NULL;
29070 wxWindow *arg1 = (wxWindow *) 0 ;
29071 wxWindow *arg2 = (wxWindow *) 0 ;
29072 PyObject * obj0 = 0 ;
29073 PyObject * obj1 = 0 ;
29074 char *kwnames[] = {
29075 (char *) "self",(char *) "child", NULL
29076 };
29077
29078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29080 if (SWIG_arg_fail(1)) SWIG_fail;
29081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29082 if (SWIG_arg_fail(2)) SWIG_fail;
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 (arg1)->RemoveChild(arg2);
29086
29087 wxPyEndAllowThreads(__tstate);
29088 if (PyErr_Occurred()) SWIG_fail;
29089 }
29090 Py_INCREF(Py_None); resultobj = Py_None;
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj = NULL;
29099 wxWindow *arg1 = (wxWindow *) 0 ;
29100 long arg2 ;
29101 wxWindow *result;
29102 PyObject * obj0 = 0 ;
29103 PyObject * obj1 = 0 ;
29104 char *kwnames[] = {
29105 (char *) "self",(char *) "winid", NULL
29106 };
29107
29108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(1)) SWIG_fail;
29111 {
29112 arg2 = static_cast<long >(SWIG_As_long(obj1));
29113 if (SWIG_arg_fail(2)) SWIG_fail;
29114 }
29115 {
29116 PyThreadState* __tstate = wxPyBeginAllowThreads();
29117 result = (wxWindow *)(arg1)->FindWindow(arg2);
29118
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 {
29123 resultobj = wxPyMake_wxObject(result, 0);
29124 }
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj = NULL;
29133 wxWindow *arg1 = (wxWindow *) 0 ;
29134 wxString *arg2 = 0 ;
29135 wxWindow *result;
29136 bool temp2 = false ;
29137 PyObject * obj0 = 0 ;
29138 PyObject * obj1 = 0 ;
29139 char *kwnames[] = {
29140 (char *) "self",(char *) "name", NULL
29141 };
29142
29143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29145 if (SWIG_arg_fail(1)) SWIG_fail;
29146 {
29147 arg2 = wxString_in_helper(obj1);
29148 if (arg2 == NULL) SWIG_fail;
29149 temp2 = true;
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29154
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 {
29159 resultobj = wxPyMake_wxObject(result, 0);
29160 }
29161 {
29162 if (temp2)
29163 delete arg2;
29164 }
29165 return resultobj;
29166 fail:
29167 {
29168 if (temp2)
29169 delete arg2;
29170 }
29171 return NULL;
29172 }
29173
29174
29175 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj = NULL;
29177 wxWindow *arg1 = (wxWindow *) 0 ;
29178 wxEvtHandler *result;
29179 PyObject * obj0 = 0 ;
29180 char *kwnames[] = {
29181 (char *) "self", NULL
29182 };
29183
29184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29186 if (SWIG_arg_fail(1)) SWIG_fail;
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29190
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 {
29195 resultobj = wxPyMake_wxObject(result, 0);
29196 }
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj = NULL;
29205 wxWindow *arg1 = (wxWindow *) 0 ;
29206 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29207 PyObject * obj0 = 0 ;
29208 PyObject * obj1 = 0 ;
29209 char *kwnames[] = {
29210 (char *) "self",(char *) "handler", NULL
29211 };
29212
29213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29215 if (SWIG_arg_fail(1)) SWIG_fail;
29216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29217 if (SWIG_arg_fail(2)) SWIG_fail;
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->SetEventHandler(arg2);
29221
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 Py_INCREF(Py_None); resultobj = Py_None;
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj = NULL;
29234 wxWindow *arg1 = (wxWindow *) 0 ;
29235 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29236 PyObject * obj0 = 0 ;
29237 PyObject * obj1 = 0 ;
29238 char *kwnames[] = {
29239 (char *) "self",(char *) "handler", NULL
29240 };
29241
29242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29244 if (SWIG_arg_fail(1)) SWIG_fail;
29245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29246 if (SWIG_arg_fail(2)) SWIG_fail;
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 (arg1)->PushEventHandler(arg2);
29250
29251 wxPyEndAllowThreads(__tstate);
29252 if (PyErr_Occurred()) SWIG_fail;
29253 }
29254 Py_INCREF(Py_None); resultobj = Py_None;
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29262 PyObject *resultobj = NULL;
29263 wxWindow *arg1 = (wxWindow *) 0 ;
29264 bool arg2 = (bool) false ;
29265 wxEvtHandler *result;
29266 PyObject * obj0 = 0 ;
29267 PyObject * obj1 = 0 ;
29268 char *kwnames[] = {
29269 (char *) "self",(char *) "deleteHandler", NULL
29270 };
29271
29272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29274 if (SWIG_arg_fail(1)) SWIG_fail;
29275 if (obj1) {
29276 {
29277 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29278 if (SWIG_arg_fail(2)) SWIG_fail;
29279 }
29280 }
29281 {
29282 PyThreadState* __tstate = wxPyBeginAllowThreads();
29283 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29284
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 {
29289 resultobj = wxPyMake_wxObject(result, 0);
29290 }
29291 return resultobj;
29292 fail:
29293 return NULL;
29294 }
29295
29296
29297 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29298 PyObject *resultobj = NULL;
29299 wxWindow *arg1 = (wxWindow *) 0 ;
29300 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29301 bool result;
29302 PyObject * obj0 = 0 ;
29303 PyObject * obj1 = 0 ;
29304 char *kwnames[] = {
29305 (char *) "self",(char *) "handler", NULL
29306 };
29307
29308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29310 if (SWIG_arg_fail(1)) SWIG_fail;
29311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29312 if (SWIG_arg_fail(2)) SWIG_fail;
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 result = (bool)(arg1)->RemoveEventHandler(arg2);
29316
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 {
29321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29322 }
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29330 PyObject *resultobj = NULL;
29331 wxWindow *arg1 = (wxWindow *) 0 ;
29332 wxValidator *arg2 = 0 ;
29333 PyObject * obj0 = 0 ;
29334 PyObject * obj1 = 0 ;
29335 char *kwnames[] = {
29336 (char *) "self",(char *) "validator", NULL
29337 };
29338
29339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29341 if (SWIG_arg_fail(1)) SWIG_fail;
29342 {
29343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29344 if (SWIG_arg_fail(2)) SWIG_fail;
29345 if (arg2 == NULL) {
29346 SWIG_null_ref("wxValidator");
29347 }
29348 if (SWIG_arg_fail(2)) SWIG_fail;
29349 }
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->SetValidator((wxValidator const &)*arg2);
29353
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 Py_INCREF(Py_None); resultobj = Py_None;
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj = NULL;
29366 wxWindow *arg1 = (wxWindow *) 0 ;
29367 wxValidator *result;
29368 PyObject * obj0 = 0 ;
29369 char *kwnames[] = {
29370 (char *) "self", NULL
29371 };
29372
29373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29375 if (SWIG_arg_fail(1)) SWIG_fail;
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 result = (wxValidator *)(arg1)->GetValidator();
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 {
29384 resultobj = wxPyMake_wxObject(result, 0);
29385 }
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj = NULL;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 bool result;
29396 PyObject * obj0 = 0 ;
29397 char *kwnames[] = {
29398 (char *) "self", NULL
29399 };
29400
29401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = (bool)(arg1)->Validate();
29407
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 {
29412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29413 }
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = NULL;
29422 wxWindow *arg1 = (wxWindow *) 0 ;
29423 bool result;
29424 PyObject * obj0 = 0 ;
29425 char *kwnames[] = {
29426 (char *) "self", NULL
29427 };
29428
29429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29431 if (SWIG_arg_fail(1)) SWIG_fail;
29432 {
29433 PyThreadState* __tstate = wxPyBeginAllowThreads();
29434 result = (bool)(arg1)->TransferDataToWindow();
29435
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 {
29440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29441 }
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29449 PyObject *resultobj = NULL;
29450 wxWindow *arg1 = (wxWindow *) 0 ;
29451 bool result;
29452 PyObject * obj0 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (bool)(arg1)->TransferDataFromWindow();
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = NULL;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 PyObject * obj0 = 0 ;
29480 char *kwnames[] = {
29481 (char *) "self", NULL
29482 };
29483
29484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29486 if (SWIG_arg_fail(1)) SWIG_fail;
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->InitDialog();
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 Py_INCREF(Py_None); resultobj = Py_None;
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29502 PyObject *resultobj = NULL;
29503 wxWindow *arg1 = (wxWindow *) 0 ;
29504 wxAcceleratorTable *arg2 = 0 ;
29505 PyObject * obj0 = 0 ;
29506 PyObject * obj1 = 0 ;
29507 char *kwnames[] = {
29508 (char *) "self",(char *) "accel", NULL
29509 };
29510
29511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29513 if (SWIG_arg_fail(1)) SWIG_fail;
29514 {
29515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29516 if (SWIG_arg_fail(2)) SWIG_fail;
29517 if (arg2 == NULL) {
29518 SWIG_null_ref("wxAcceleratorTable");
29519 }
29520 if (SWIG_arg_fail(2)) SWIG_fail;
29521 }
29522 {
29523 PyThreadState* __tstate = wxPyBeginAllowThreads();
29524 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29525
29526 wxPyEndAllowThreads(__tstate);
29527 if (PyErr_Occurred()) SWIG_fail;
29528 }
29529 Py_INCREF(Py_None); resultobj = Py_None;
29530 return resultobj;
29531 fail:
29532 return NULL;
29533 }
29534
29535
29536 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29537 PyObject *resultobj = NULL;
29538 wxWindow *arg1 = (wxWindow *) 0 ;
29539 wxAcceleratorTable *result;
29540 PyObject * obj0 = 0 ;
29541 char *kwnames[] = {
29542 (char *) "self", NULL
29543 };
29544
29545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29547 if (SWIG_arg_fail(1)) SWIG_fail;
29548 {
29549 PyThreadState* __tstate = wxPyBeginAllowThreads();
29550 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29551
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj = NULL;
29564 wxWindow *arg1 = (wxWindow *) 0 ;
29565 int arg2 ;
29566 int arg3 ;
29567 int arg4 ;
29568 bool result;
29569 PyObject * obj0 = 0 ;
29570 PyObject * obj1 = 0 ;
29571 PyObject * obj2 = 0 ;
29572 PyObject * obj3 = 0 ;
29573 char *kwnames[] = {
29574 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29575 };
29576
29577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29579 if (SWIG_arg_fail(1)) SWIG_fail;
29580 {
29581 arg2 = static_cast<int >(SWIG_As_int(obj1));
29582 if (SWIG_arg_fail(2)) SWIG_fail;
29583 }
29584 {
29585 arg3 = static_cast<int >(SWIG_As_int(obj2));
29586 if (SWIG_arg_fail(3)) SWIG_fail;
29587 }
29588 {
29589 arg4 = static_cast<int >(SWIG_As_int(obj3));
29590 if (SWIG_arg_fail(4)) SWIG_fail;
29591 }
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 {
29600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29601 }
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29609 PyObject *resultobj = NULL;
29610 wxWindow *arg1 = (wxWindow *) 0 ;
29611 int arg2 ;
29612 bool result;
29613 PyObject * obj0 = 0 ;
29614 PyObject * obj1 = 0 ;
29615 char *kwnames[] = {
29616 (char *) "self",(char *) "hotkeyId", NULL
29617 };
29618
29619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29621 if (SWIG_arg_fail(1)) SWIG_fail;
29622 {
29623 arg2 = static_cast<int >(SWIG_As_int(obj1));
29624 if (SWIG_arg_fail(2)) SWIG_fail;
29625 }
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29629
29630 wxPyEndAllowThreads(__tstate);
29631 if (PyErr_Occurred()) SWIG_fail;
29632 }
29633 {
29634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29635 }
29636 return resultobj;
29637 fail:
29638 return NULL;
29639 }
29640
29641
29642 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29643 PyObject *resultobj = NULL;
29644 wxWindow *arg1 = (wxWindow *) 0 ;
29645 wxPoint *arg2 = 0 ;
29646 wxPoint result;
29647 wxPoint temp2 ;
29648 PyObject * obj0 = 0 ;
29649 PyObject * obj1 = 0 ;
29650 char *kwnames[] = {
29651 (char *) "self",(char *) "pt", NULL
29652 };
29653
29654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29656 if (SWIG_arg_fail(1)) SWIG_fail;
29657 {
29658 arg2 = &temp2;
29659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29660 }
29661 {
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29664
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 wxPoint * resultptr;
29670 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29672 }
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29680 PyObject *resultobj = NULL;
29681 wxWindow *arg1 = (wxWindow *) 0 ;
29682 wxSize *arg2 = 0 ;
29683 wxSize result;
29684 wxSize temp2 ;
29685 PyObject * obj0 = 0 ;
29686 PyObject * obj1 = 0 ;
29687 char *kwnames[] = {
29688 (char *) "self",(char *) "sz", NULL
29689 };
29690
29691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 {
29695 arg2 = &temp2;
29696 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29697 }
29698 {
29699 PyThreadState* __tstate = wxPyBeginAllowThreads();
29700 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29701
29702 wxPyEndAllowThreads(__tstate);
29703 if (PyErr_Occurred()) SWIG_fail;
29704 }
29705 {
29706 wxSize * resultptr;
29707 resultptr = new wxSize(static_cast<wxSize & >(result));
29708 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29709 }
29710 return resultobj;
29711 fail:
29712 return NULL;
29713 }
29714
29715
29716 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29717 PyObject *resultobj = NULL;
29718 wxWindow *arg1 = (wxWindow *) 0 ;
29719 wxPoint *arg2 = 0 ;
29720 wxPoint result;
29721 wxPoint temp2 ;
29722 PyObject * obj0 = 0 ;
29723 PyObject * obj1 = 0 ;
29724 char *kwnames[] = {
29725 (char *) "self",(char *) "pt", NULL
29726 };
29727
29728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29730 if (SWIG_arg_fail(1)) SWIG_fail;
29731 {
29732 arg2 = &temp2;
29733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29734 }
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29738
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 {
29743 wxPoint * resultptr;
29744 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29745 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29746 }
29747 return resultobj;
29748 fail:
29749 return NULL;
29750 }
29751
29752
29753 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29754 PyObject *resultobj = NULL;
29755 wxWindow *arg1 = (wxWindow *) 0 ;
29756 wxSize *arg2 = 0 ;
29757 wxSize result;
29758 wxSize temp2 ;
29759 PyObject * obj0 = 0 ;
29760 PyObject * obj1 = 0 ;
29761 char *kwnames[] = {
29762 (char *) "self",(char *) "sz", NULL
29763 };
29764
29765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29767 if (SWIG_arg_fail(1)) SWIG_fail;
29768 {
29769 arg2 = &temp2;
29770 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29771 }
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 {
29780 wxSize * resultptr;
29781 resultptr = new wxSize(static_cast<wxSize & >(result));
29782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29783 }
29784 return resultobj;
29785 fail:
29786 return NULL;
29787 }
29788
29789
29790 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29791 PyObject *resultobj = NULL;
29792 wxWindow *arg1 = (wxWindow *) 0 ;
29793 wxPoint *arg2 = 0 ;
29794 wxPoint result;
29795 wxPoint temp2 ;
29796 PyObject * obj0 = 0 ;
29797 PyObject * obj1 = 0 ;
29798 char *kwnames[] = {
29799 (char *) "self",(char *) "pt", NULL
29800 };
29801
29802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29804 if (SWIG_arg_fail(1)) SWIG_fail;
29805 {
29806 arg2 = &temp2;
29807 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29808 }
29809 {
29810 PyThreadState* __tstate = wxPyBeginAllowThreads();
29811 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29812
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 {
29817 wxPoint * resultptr;
29818 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29820 }
29821 return resultobj;
29822 fail:
29823 return NULL;
29824 }
29825
29826
29827 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj = NULL;
29829 wxWindow *arg1 = (wxWindow *) 0 ;
29830 wxSize *arg2 = 0 ;
29831 wxSize result;
29832 wxSize temp2 ;
29833 PyObject * obj0 = 0 ;
29834 PyObject * obj1 = 0 ;
29835 char *kwnames[] = {
29836 (char *) "self",(char *) "sz", NULL
29837 };
29838
29839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29841 if (SWIG_arg_fail(1)) SWIG_fail;
29842 {
29843 arg2 = &temp2;
29844 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29845 }
29846 {
29847 PyThreadState* __tstate = wxPyBeginAllowThreads();
29848 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29849
29850 wxPyEndAllowThreads(__tstate);
29851 if (PyErr_Occurred()) SWIG_fail;
29852 }
29853 {
29854 wxSize * resultptr;
29855 resultptr = new wxSize(static_cast<wxSize & >(result));
29856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29857 }
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29865 PyObject *resultobj = NULL;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 int arg2 ;
29868 int arg3 ;
29869 PyObject * obj0 = 0 ;
29870 PyObject * obj1 = 0 ;
29871 PyObject * obj2 = 0 ;
29872 char *kwnames[] = {
29873 (char *) "self",(char *) "x",(char *) "y", NULL
29874 };
29875
29876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29878 if (SWIG_arg_fail(1)) SWIG_fail;
29879 {
29880 arg2 = static_cast<int >(SWIG_As_int(obj1));
29881 if (SWIG_arg_fail(2)) SWIG_fail;
29882 }
29883 {
29884 arg3 = static_cast<int >(SWIG_As_int(obj2));
29885 if (SWIG_arg_fail(3)) SWIG_fail;
29886 }
29887 {
29888 PyThreadState* __tstate = wxPyBeginAllowThreads();
29889 (arg1)->WarpPointer(arg2,arg3);
29890
29891 wxPyEndAllowThreads(__tstate);
29892 if (PyErr_Occurred()) SWIG_fail;
29893 }
29894 Py_INCREF(Py_None); resultobj = Py_None;
29895 return resultobj;
29896 fail:
29897 return NULL;
29898 }
29899
29900
29901 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29902 PyObject *resultobj = NULL;
29903 wxWindow *arg1 = (wxWindow *) 0 ;
29904 PyObject * obj0 = 0 ;
29905 char *kwnames[] = {
29906 (char *) "self", NULL
29907 };
29908
29909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29911 if (SWIG_arg_fail(1)) SWIG_fail;
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 (arg1)->CaptureMouse();
29915
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 Py_INCREF(Py_None); resultobj = Py_None;
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29927 PyObject *resultobj = NULL;
29928 wxWindow *arg1 = (wxWindow *) 0 ;
29929 PyObject * obj0 = 0 ;
29930 char *kwnames[] = {
29931 (char *) "self", NULL
29932 };
29933
29934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29936 if (SWIG_arg_fail(1)) SWIG_fail;
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 (arg1)->ReleaseMouse();
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 Py_INCREF(Py_None); resultobj = Py_None;
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj = NULL;
29953 wxWindow *result;
29954 char *kwnames[] = {
29955 NULL
29956 };
29957
29958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29959 {
29960 if (!wxPyCheckForApp()) SWIG_fail;
29961 PyThreadState* __tstate = wxPyBeginAllowThreads();
29962 result = (wxWindow *)wxWindow::GetCapture();
29963
29964 wxPyEndAllowThreads(__tstate);
29965 if (PyErr_Occurred()) SWIG_fail;
29966 }
29967 {
29968 resultobj = wxPyMake_wxObject(result, 0);
29969 }
29970 return resultobj;
29971 fail:
29972 return NULL;
29973 }
29974
29975
29976 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29977 PyObject *resultobj = NULL;
29978 wxWindow *arg1 = (wxWindow *) 0 ;
29979 bool result;
29980 PyObject * obj0 = 0 ;
29981 char *kwnames[] = {
29982 (char *) "self", NULL
29983 };
29984
29985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(1)) SWIG_fail;
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = (bool)((wxWindow const *)arg1)->HasCapture();
29991
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 {
29996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29997 }
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30005 PyObject *resultobj = NULL;
30006 wxWindow *arg1 = (wxWindow *) 0 ;
30007 bool arg2 = (bool) true ;
30008 wxRect *arg3 = (wxRect *) NULL ;
30009 PyObject * obj0 = 0 ;
30010 PyObject * obj1 = 0 ;
30011 PyObject * obj2 = 0 ;
30012 char *kwnames[] = {
30013 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30014 };
30015
30016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30018 if (SWIG_arg_fail(1)) SWIG_fail;
30019 if (obj1) {
30020 {
30021 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30022 if (SWIG_arg_fail(2)) SWIG_fail;
30023 }
30024 }
30025 if (obj2) {
30026 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(3)) SWIG_fail;
30028 }
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30032
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 Py_INCREF(Py_None); resultobj = Py_None;
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30044 PyObject *resultobj = NULL;
30045 wxWindow *arg1 = (wxWindow *) 0 ;
30046 wxRect *arg2 = 0 ;
30047 bool arg3 = (bool) true ;
30048 wxRect temp2 ;
30049 PyObject * obj0 = 0 ;
30050 PyObject * obj1 = 0 ;
30051 PyObject * obj2 = 0 ;
30052 char *kwnames[] = {
30053 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30054 };
30055
30056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(1)) SWIG_fail;
30059 {
30060 arg2 = &temp2;
30061 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30062 }
30063 if (obj2) {
30064 {
30065 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30066 if (SWIG_arg_fail(3)) SWIG_fail;
30067 }
30068 }
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30072
30073 wxPyEndAllowThreads(__tstate);
30074 if (PyErr_Occurred()) SWIG_fail;
30075 }
30076 Py_INCREF(Py_None); resultobj = Py_None;
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30084 PyObject *resultobj = NULL;
30085 wxWindow *arg1 = (wxWindow *) 0 ;
30086 PyObject * obj0 = 0 ;
30087 char *kwnames[] = {
30088 (char *) "self", NULL
30089 };
30090
30091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30093 if (SWIG_arg_fail(1)) SWIG_fail;
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 (arg1)->Update();
30097
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 Py_INCREF(Py_None); resultobj = Py_None;
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj = NULL;
30110 wxWindow *arg1 = (wxWindow *) 0 ;
30111 PyObject * obj0 = 0 ;
30112 char *kwnames[] = {
30113 (char *) "self", NULL
30114 };
30115
30116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30118 if (SWIG_arg_fail(1)) SWIG_fail;
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 (arg1)->ClearBackground();
30122
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 Py_INCREF(Py_None); resultobj = Py_None;
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj = NULL;
30135 wxWindow *arg1 = (wxWindow *) 0 ;
30136 PyObject * obj0 = 0 ;
30137 char *kwnames[] = {
30138 (char *) "self", NULL
30139 };
30140
30141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30143 if (SWIG_arg_fail(1)) SWIG_fail;
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 (arg1)->Freeze();
30147
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 Py_INCREF(Py_None); resultobj = Py_None;
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30159 PyObject *resultobj = NULL;
30160 wxWindow *arg1 = (wxWindow *) 0 ;
30161 PyObject * obj0 = 0 ;
30162 char *kwnames[] = {
30163 (char *) "self", NULL
30164 };
30165
30166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30168 if (SWIG_arg_fail(1)) SWIG_fail;
30169 {
30170 PyThreadState* __tstate = wxPyBeginAllowThreads();
30171 (arg1)->Thaw();
30172
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 Py_INCREF(Py_None); resultobj = Py_None;
30177 return resultobj;
30178 fail:
30179 return NULL;
30180 }
30181
30182
30183 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30184 PyObject *resultobj = NULL;
30185 wxWindow *arg1 = (wxWindow *) 0 ;
30186 wxDC *arg2 = 0 ;
30187 PyObject * obj0 = 0 ;
30188 PyObject * obj1 = 0 ;
30189 char *kwnames[] = {
30190 (char *) "self",(char *) "dc", NULL
30191 };
30192
30193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30195 if (SWIG_arg_fail(1)) SWIG_fail;
30196 {
30197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30198 if (SWIG_arg_fail(2)) SWIG_fail;
30199 if (arg2 == NULL) {
30200 SWIG_null_ref("wxDC");
30201 }
30202 if (SWIG_arg_fail(2)) SWIG_fail;
30203 }
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->PrepareDC(*arg2);
30207
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 Py_INCREF(Py_None); resultobj = Py_None;
30212 return resultobj;
30213 fail:
30214 return NULL;
30215 }
30216
30217
30218 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj = NULL;
30220 wxWindow *arg1 = (wxWindow *) 0 ;
30221 wxRegion *result;
30222 PyObject * obj0 = 0 ;
30223 char *kwnames[] = {
30224 (char *) "self", NULL
30225 };
30226
30227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30229 if (SWIG_arg_fail(1)) SWIG_fail;
30230 {
30231 PyThreadState* __tstate = wxPyBeginAllowThreads();
30232 {
30233 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30234 result = (wxRegion *) &_result_ref;
30235 }
30236
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30248 PyObject *resultobj = NULL;
30249 wxWindow *arg1 = (wxWindow *) 0 ;
30250 wxRect result;
30251 PyObject * obj0 = 0 ;
30252 char *kwnames[] = {
30253 (char *) "self", NULL
30254 };
30255
30256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30258 if (SWIG_arg_fail(1)) SWIG_fail;
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30262
30263 wxPyEndAllowThreads(__tstate);
30264 if (PyErr_Occurred()) SWIG_fail;
30265 }
30266 {
30267 wxRect * resultptr;
30268 resultptr = new wxRect(static_cast<wxRect & >(result));
30269 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30270 }
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = NULL;
30279 wxWindow *arg1 = (wxWindow *) 0 ;
30280 int arg2 ;
30281 int arg3 ;
30282 int arg4 = (int) 1 ;
30283 int arg5 = (int) 1 ;
30284 bool result;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 PyObject * obj2 = 0 ;
30288 PyObject * obj3 = 0 ;
30289 PyObject * obj4 = 0 ;
30290 char *kwnames[] = {
30291 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30292 };
30293
30294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30296 if (SWIG_arg_fail(1)) SWIG_fail;
30297 {
30298 arg2 = static_cast<int >(SWIG_As_int(obj1));
30299 if (SWIG_arg_fail(2)) SWIG_fail;
30300 }
30301 {
30302 arg3 = static_cast<int >(SWIG_As_int(obj2));
30303 if (SWIG_arg_fail(3)) SWIG_fail;
30304 }
30305 if (obj3) {
30306 {
30307 arg4 = static_cast<int >(SWIG_As_int(obj3));
30308 if (SWIG_arg_fail(4)) SWIG_fail;
30309 }
30310 }
30311 if (obj4) {
30312 {
30313 arg5 = static_cast<int >(SWIG_As_int(obj4));
30314 if (SWIG_arg_fail(5)) SWIG_fail;
30315 }
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30320
30321 wxPyEndAllowThreads(__tstate);
30322 if (PyErr_Occurred()) SWIG_fail;
30323 }
30324 {
30325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30326 }
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj = NULL;
30335 wxWindow *arg1 = (wxWindow *) 0 ;
30336 wxPoint *arg2 = 0 ;
30337 bool result;
30338 wxPoint temp2 ;
30339 PyObject * obj0 = 0 ;
30340 PyObject * obj1 = 0 ;
30341 char *kwnames[] = {
30342 (char *) "self",(char *) "pt", NULL
30343 };
30344
30345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(1)) SWIG_fail;
30348 {
30349 arg2 = &temp2;
30350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30351 }
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 {
30360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30361 }
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30369 PyObject *resultobj = NULL;
30370 wxWindow *arg1 = (wxWindow *) 0 ;
30371 wxRect *arg2 = 0 ;
30372 bool result;
30373 wxRect temp2 ;
30374 PyObject * obj0 = 0 ;
30375 PyObject * obj1 = 0 ;
30376 char *kwnames[] = {
30377 (char *) "self",(char *) "rect", NULL
30378 };
30379
30380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30382 if (SWIG_arg_fail(1)) SWIG_fail;
30383 {
30384 arg2 = &temp2;
30385 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30386 }
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30390
30391 wxPyEndAllowThreads(__tstate);
30392 if (PyErr_Occurred()) SWIG_fail;
30393 }
30394 {
30395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30396 }
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj = NULL;
30405 wxWindow *arg1 = (wxWindow *) 0 ;
30406 wxVisualAttributes result;
30407 PyObject * obj0 = 0 ;
30408 char *kwnames[] = {
30409 (char *) "self", NULL
30410 };
30411
30412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30414 if (SWIG_arg_fail(1)) SWIG_fail;
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 {
30423 wxVisualAttributes * resultptr;
30424 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30426 }
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30434 PyObject *resultobj = NULL;
30435 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30436 wxVisualAttributes result;
30437 PyObject * obj0 = 0 ;
30438 char *kwnames[] = {
30439 (char *) "variant", NULL
30440 };
30441
30442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30443 if (obj0) {
30444 {
30445 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30446 if (SWIG_arg_fail(1)) SWIG_fail;
30447 }
30448 }
30449 {
30450 if (!wxPyCheckForApp()) SWIG_fail;
30451 PyThreadState* __tstate = wxPyBeginAllowThreads();
30452 result = wxWindow::GetClassDefaultAttributes(arg1);
30453
30454 wxPyEndAllowThreads(__tstate);
30455 if (PyErr_Occurred()) SWIG_fail;
30456 }
30457 {
30458 wxVisualAttributes * resultptr;
30459 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30461 }
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30469 PyObject *resultobj = NULL;
30470 wxWindow *arg1 = (wxWindow *) 0 ;
30471 wxColour *arg2 = 0 ;
30472 bool result;
30473 wxColour temp2 ;
30474 PyObject * obj0 = 0 ;
30475 PyObject * obj1 = 0 ;
30476 char *kwnames[] = {
30477 (char *) "self",(char *) "colour", NULL
30478 };
30479
30480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30482 if (SWIG_arg_fail(1)) SWIG_fail;
30483 {
30484 arg2 = &temp2;
30485 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30486 }
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30490
30491 wxPyEndAllowThreads(__tstate);
30492 if (PyErr_Occurred()) SWIG_fail;
30493 }
30494 {
30495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30496 }
30497 return resultobj;
30498 fail:
30499 return NULL;
30500 }
30501
30502
30503 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30504 PyObject *resultobj = NULL;
30505 wxWindow *arg1 = (wxWindow *) 0 ;
30506 wxColour *arg2 = 0 ;
30507 wxColour temp2 ;
30508 PyObject * obj0 = 0 ;
30509 PyObject * obj1 = 0 ;
30510 char *kwnames[] = {
30511 (char *) "self",(char *) "colour", NULL
30512 };
30513
30514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30516 if (SWIG_arg_fail(1)) SWIG_fail;
30517 {
30518 arg2 = &temp2;
30519 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30520 }
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30524
30525 wxPyEndAllowThreads(__tstate);
30526 if (PyErr_Occurred()) SWIG_fail;
30527 }
30528 Py_INCREF(Py_None); resultobj = Py_None;
30529 return resultobj;
30530 fail:
30531 return NULL;
30532 }
30533
30534
30535 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30536 PyObject *resultobj = NULL;
30537 wxWindow *arg1 = (wxWindow *) 0 ;
30538 wxColour *arg2 = 0 ;
30539 bool result;
30540 wxColour temp2 ;
30541 PyObject * obj0 = 0 ;
30542 PyObject * obj1 = 0 ;
30543 char *kwnames[] = {
30544 (char *) "self",(char *) "colour", NULL
30545 };
30546
30547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30549 if (SWIG_arg_fail(1)) SWIG_fail;
30550 {
30551 arg2 = &temp2;
30552 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30553 }
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30557
30558 wxPyEndAllowThreads(__tstate);
30559 if (PyErr_Occurred()) SWIG_fail;
30560 }
30561 {
30562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30563 }
30564 return resultobj;
30565 fail:
30566 return NULL;
30567 }
30568
30569
30570 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30571 PyObject *resultobj = NULL;
30572 wxWindow *arg1 = (wxWindow *) 0 ;
30573 wxColour *arg2 = 0 ;
30574 wxColour temp2 ;
30575 PyObject * obj0 = 0 ;
30576 PyObject * obj1 = 0 ;
30577 char *kwnames[] = {
30578 (char *) "self",(char *) "colour", NULL
30579 };
30580
30581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30583 if (SWIG_arg_fail(1)) SWIG_fail;
30584 {
30585 arg2 = &temp2;
30586 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30587 }
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30591
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 Py_INCREF(Py_None); resultobj = Py_None;
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj = NULL;
30604 wxWindow *arg1 = (wxWindow *) 0 ;
30605 wxColour result;
30606 PyObject * obj0 = 0 ;
30607 char *kwnames[] = {
30608 (char *) "self", NULL
30609 };
30610
30611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30613 if (SWIG_arg_fail(1)) SWIG_fail;
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30617
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 {
30622 wxColour * resultptr;
30623 resultptr = new wxColour(static_cast<wxColour & >(result));
30624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30625 }
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj = NULL;
30634 wxWindow *arg1 = (wxWindow *) 0 ;
30635 wxColour result;
30636 PyObject * obj0 = 0 ;
30637 char *kwnames[] = {
30638 (char *) "self", NULL
30639 };
30640
30641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30643 if (SWIG_arg_fail(1)) SWIG_fail;
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 result = ((wxWindow const *)arg1)->GetForegroundColour();
30647
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 {
30652 wxColour * resultptr;
30653 resultptr = new wxColour(static_cast<wxColour & >(result));
30654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30655 }
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30663 PyObject *resultobj = NULL;
30664 wxWindow *arg1 = (wxWindow *) 0 ;
30665 bool result;
30666 PyObject * obj0 = 0 ;
30667 char *kwnames[] = {
30668 (char *) "self", NULL
30669 };
30670
30671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30673 if (SWIG_arg_fail(1)) SWIG_fail;
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30677
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 {
30682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30683 }
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj = NULL;
30692 wxWindow *arg1 = (wxWindow *) 0 ;
30693 bool result;
30694 PyObject * obj0 = 0 ;
30695 char *kwnames[] = {
30696 (char *) "self", NULL
30697 };
30698
30699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30701 if (SWIG_arg_fail(1)) SWIG_fail;
30702 {
30703 PyThreadState* __tstate = wxPyBeginAllowThreads();
30704 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30705
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 {
30710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30711 }
30712 return resultobj;
30713 fail:
30714 return NULL;
30715 }
30716
30717
30718 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30719 PyObject *resultobj = NULL;
30720 wxWindow *arg1 = (wxWindow *) 0 ;
30721 wxBackgroundStyle arg2 ;
30722 bool result;
30723 PyObject * obj0 = 0 ;
30724 PyObject * obj1 = 0 ;
30725 char *kwnames[] = {
30726 (char *) "self",(char *) "style", NULL
30727 };
30728
30729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30731 if (SWIG_arg_fail(1)) SWIG_fail;
30732 {
30733 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30734 if (SWIG_arg_fail(2)) SWIG_fail;
30735 }
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30739
30740 wxPyEndAllowThreads(__tstate);
30741 if (PyErr_Occurred()) SWIG_fail;
30742 }
30743 {
30744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30745 }
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj = NULL;
30754 wxWindow *arg1 = (wxWindow *) 0 ;
30755 wxBackgroundStyle result;
30756 PyObject * obj0 = 0 ;
30757 char *kwnames[] = {
30758 (char *) "self", NULL
30759 };
30760
30761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30763 if (SWIG_arg_fail(1)) SWIG_fail;
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30767
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 resultobj = SWIG_From_int((result));
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj = NULL;
30780 wxWindow *arg1 = (wxWindow *) 0 ;
30781 bool result;
30782 PyObject * obj0 = 0 ;
30783 char *kwnames[] = {
30784 (char *) "self", NULL
30785 };
30786
30787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30789 if (SWIG_arg_fail(1)) SWIG_fail;
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = (bool)(arg1)->HasTransparentBackground();
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 {
30798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30799 }
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30807 PyObject *resultobj = NULL;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 wxCursor *arg2 = 0 ;
30810 bool result;
30811 PyObject * obj0 = 0 ;
30812 PyObject * obj1 = 0 ;
30813 char *kwnames[] = {
30814 (char *) "self",(char *) "cursor", NULL
30815 };
30816
30817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30819 if (SWIG_arg_fail(1)) SWIG_fail;
30820 {
30821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(2)) SWIG_fail;
30823 if (arg2 == NULL) {
30824 SWIG_null_ref("wxCursor");
30825 }
30826 if (SWIG_arg_fail(2)) SWIG_fail;
30827 }
30828 {
30829 PyThreadState* __tstate = wxPyBeginAllowThreads();
30830 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30831
30832 wxPyEndAllowThreads(__tstate);
30833 if (PyErr_Occurred()) SWIG_fail;
30834 }
30835 {
30836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30837 }
30838 return resultobj;
30839 fail:
30840 return NULL;
30841 }
30842
30843
30844 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30845 PyObject *resultobj = NULL;
30846 wxWindow *arg1 = (wxWindow *) 0 ;
30847 wxCursor result;
30848 PyObject * obj0 = 0 ;
30849 char *kwnames[] = {
30850 (char *) "self", NULL
30851 };
30852
30853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30855 if (SWIG_arg_fail(1)) SWIG_fail;
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 result = (arg1)->GetCursor();
30859
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 {
30864 wxCursor * resultptr;
30865 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30867 }
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj = NULL;
30876 wxWindow *arg1 = (wxWindow *) 0 ;
30877 wxFont *arg2 = 0 ;
30878 bool result;
30879 PyObject * obj0 = 0 ;
30880 PyObject * obj1 = 0 ;
30881 char *kwnames[] = {
30882 (char *) "self",(char *) "font", NULL
30883 };
30884
30885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30887 if (SWIG_arg_fail(1)) SWIG_fail;
30888 {
30889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30890 if (SWIG_arg_fail(2)) SWIG_fail;
30891 if (arg2 == NULL) {
30892 SWIG_null_ref("wxFont");
30893 }
30894 if (SWIG_arg_fail(2)) SWIG_fail;
30895 }
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30899
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 {
30904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30905 }
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj = NULL;
30914 wxWindow *arg1 = (wxWindow *) 0 ;
30915 wxFont *arg2 = 0 ;
30916 PyObject * obj0 = 0 ;
30917 PyObject * obj1 = 0 ;
30918 char *kwnames[] = {
30919 (char *) "self",(char *) "font", NULL
30920 };
30921
30922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30924 if (SWIG_arg_fail(1)) SWIG_fail;
30925 {
30926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30927 if (SWIG_arg_fail(2)) SWIG_fail;
30928 if (arg2 == NULL) {
30929 SWIG_null_ref("wxFont");
30930 }
30931 if (SWIG_arg_fail(2)) SWIG_fail;
30932 }
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 (arg1)->SetOwnFont((wxFont const &)*arg2);
30936
30937 wxPyEndAllowThreads(__tstate);
30938 if (PyErr_Occurred()) SWIG_fail;
30939 }
30940 Py_INCREF(Py_None); resultobj = Py_None;
30941 return resultobj;
30942 fail:
30943 return NULL;
30944 }
30945
30946
30947 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30948 PyObject *resultobj = NULL;
30949 wxWindow *arg1 = (wxWindow *) 0 ;
30950 wxFont result;
30951 PyObject * obj0 = 0 ;
30952 char *kwnames[] = {
30953 (char *) "self", NULL
30954 };
30955
30956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30958 if (SWIG_arg_fail(1)) SWIG_fail;
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 result = (arg1)->GetFont();
30962
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 {
30967 wxFont * resultptr;
30968 resultptr = new wxFont(static_cast<wxFont & >(result));
30969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30970 }
30971 return resultobj;
30972 fail:
30973 return NULL;
30974 }
30975
30976
30977 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30978 PyObject *resultobj = NULL;
30979 wxWindow *arg1 = (wxWindow *) 0 ;
30980 wxCaret *arg2 = (wxCaret *) 0 ;
30981 PyObject * obj0 = 0 ;
30982 PyObject * obj1 = 0 ;
30983 char *kwnames[] = {
30984 (char *) "self",(char *) "caret", NULL
30985 };
30986
30987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30989 if (SWIG_arg_fail(1)) SWIG_fail;
30990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30991 if (SWIG_arg_fail(2)) SWIG_fail;
30992 {
30993 PyThreadState* __tstate = wxPyBeginAllowThreads();
30994 (arg1)->SetCaret(arg2);
30995
30996 wxPyEndAllowThreads(__tstate);
30997 if (PyErr_Occurred()) SWIG_fail;
30998 }
30999 Py_INCREF(Py_None); resultobj = Py_None;
31000 return resultobj;
31001 fail:
31002 return NULL;
31003 }
31004
31005
31006 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31007 PyObject *resultobj = NULL;
31008 wxWindow *arg1 = (wxWindow *) 0 ;
31009 wxCaret *result;
31010 PyObject * obj0 = 0 ;
31011 char *kwnames[] = {
31012 (char *) "self", NULL
31013 };
31014
31015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31017 if (SWIG_arg_fail(1)) SWIG_fail;
31018 {
31019 PyThreadState* __tstate = wxPyBeginAllowThreads();
31020 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31021
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj = NULL;
31034 wxWindow *arg1 = (wxWindow *) 0 ;
31035 int result;
31036 PyObject * obj0 = 0 ;
31037 char *kwnames[] = {
31038 (char *) "self", NULL
31039 };
31040
31041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31043 if (SWIG_arg_fail(1)) SWIG_fail;
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31047
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 {
31052 resultobj = SWIG_From_int(static_cast<int >(result));
31053 }
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31061 PyObject *resultobj = NULL;
31062 wxWindow *arg1 = (wxWindow *) 0 ;
31063 int result;
31064 PyObject * obj0 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 PyThreadState* __tstate = wxPyBeginAllowThreads();
31074 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31075
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 {
31080 resultobj = SWIG_From_int(static_cast<int >(result));
31081 }
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31089 PyObject *resultobj = NULL;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 wxString *arg2 = 0 ;
31092 int *arg3 = (int *) 0 ;
31093 int *arg4 = (int *) 0 ;
31094 bool temp2 = false ;
31095 int temp3 ;
31096 int res3 = 0 ;
31097 int temp4 ;
31098 int res4 = 0 ;
31099 PyObject * obj0 = 0 ;
31100 PyObject * obj1 = 0 ;
31101 char *kwnames[] = {
31102 (char *) "self",(char *) "string", NULL
31103 };
31104
31105 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31106 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31109 if (SWIG_arg_fail(1)) SWIG_fail;
31110 {
31111 arg2 = wxString_in_helper(obj1);
31112 if (arg2 == NULL) SWIG_fail;
31113 temp2 = true;
31114 }
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31118
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 Py_INCREF(Py_None); resultobj = Py_None;
31123 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31124 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31125 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31126 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31127 {
31128 if (temp2)
31129 delete arg2;
31130 }
31131 return resultobj;
31132 fail:
31133 {
31134 if (temp2)
31135 delete arg2;
31136 }
31137 return NULL;
31138 }
31139
31140
31141 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj = NULL;
31143 wxWindow *arg1 = (wxWindow *) 0 ;
31144 wxString *arg2 = 0 ;
31145 int *arg3 = (int *) 0 ;
31146 int *arg4 = (int *) 0 ;
31147 int *arg5 = (int *) 0 ;
31148 int *arg6 = (int *) 0 ;
31149 wxFont *arg7 = (wxFont *) NULL ;
31150 bool temp2 = false ;
31151 int temp3 ;
31152 int res3 = 0 ;
31153 int temp4 ;
31154 int res4 = 0 ;
31155 int temp5 ;
31156 int res5 = 0 ;
31157 int temp6 ;
31158 int res6 = 0 ;
31159 PyObject * obj0 = 0 ;
31160 PyObject * obj1 = 0 ;
31161 PyObject * obj2 = 0 ;
31162 char *kwnames[] = {
31163 (char *) "self",(char *) "string",(char *) "font", NULL
31164 };
31165
31166 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31167 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31168 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31169 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31172 if (SWIG_arg_fail(1)) SWIG_fail;
31173 {
31174 arg2 = wxString_in_helper(obj1);
31175 if (arg2 == NULL) SWIG_fail;
31176 temp2 = true;
31177 }
31178 if (obj2) {
31179 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31180 if (SWIG_arg_fail(7)) SWIG_fail;
31181 }
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31185
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 Py_INCREF(Py_None); resultobj = Py_None;
31190 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31191 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31192 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31193 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31194 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31195 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31196 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31197 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31198 {
31199 if (temp2)
31200 delete arg2;
31201 }
31202 return resultobj;
31203 fail:
31204 {
31205 if (temp2)
31206 delete arg2;
31207 }
31208 return NULL;
31209 }
31210
31211
31212 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31213 PyObject *resultobj = NULL;
31214 wxWindow *arg1 = (wxWindow *) 0 ;
31215 int *arg2 = (int *) 0 ;
31216 int *arg3 = (int *) 0 ;
31217 int temp2 ;
31218 int res2 = 0 ;
31219 int temp3 ;
31220 int res3 = 0 ;
31221 PyObject * obj0 = 0 ;
31222 PyObject * obj1 = 0 ;
31223 PyObject * obj2 = 0 ;
31224 char *kwnames[] = {
31225 (char *) "self",(char *) "x",(char *) "y", NULL
31226 };
31227
31228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31230 if (SWIG_arg_fail(1)) SWIG_fail;
31231 {
31232 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31233 temp2 = SWIG_As_int(obj1);
31234 if (SWIG_arg_fail(2)) SWIG_fail;
31235 arg2 = &temp2;
31236 res2 = SWIG_NEWOBJ;
31237 }
31238 }
31239 {
31240 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31241 temp3 = SWIG_As_int(obj2);
31242 if (SWIG_arg_fail(3)) SWIG_fail;
31243 arg3 = &temp3;
31244 res3 = SWIG_NEWOBJ;
31245 }
31246 }
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31250
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 Py_INCREF(Py_None); resultobj = Py_None;
31255 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31256 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31257 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31258 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31259 return resultobj;
31260 fail:
31261 return NULL;
31262 }
31263
31264
31265 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31266 PyObject *resultobj = NULL;
31267 wxWindow *arg1 = (wxWindow *) 0 ;
31268 int *arg2 = (int *) 0 ;
31269 int *arg3 = (int *) 0 ;
31270 int temp2 ;
31271 int res2 = 0 ;
31272 int temp3 ;
31273 int res3 = 0 ;
31274 PyObject * obj0 = 0 ;
31275 PyObject * obj1 = 0 ;
31276 PyObject * obj2 = 0 ;
31277 char *kwnames[] = {
31278 (char *) "self",(char *) "x",(char *) "y", NULL
31279 };
31280
31281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31283 if (SWIG_arg_fail(1)) SWIG_fail;
31284 {
31285 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31286 temp2 = SWIG_As_int(obj1);
31287 if (SWIG_arg_fail(2)) SWIG_fail;
31288 arg2 = &temp2;
31289 res2 = SWIG_NEWOBJ;
31290 }
31291 }
31292 {
31293 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31294 temp3 = SWIG_As_int(obj2);
31295 if (SWIG_arg_fail(3)) SWIG_fail;
31296 arg3 = &temp3;
31297 res3 = SWIG_NEWOBJ;
31298 }
31299 }
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31303
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 Py_INCREF(Py_None); resultobj = Py_None;
31308 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31309 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31310 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31311 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj = NULL;
31320 wxWindow *arg1 = (wxWindow *) 0 ;
31321 wxPoint *arg2 = 0 ;
31322 wxPoint result;
31323 wxPoint temp2 ;
31324 PyObject * obj0 = 0 ;
31325 PyObject * obj1 = 0 ;
31326 char *kwnames[] = {
31327 (char *) "self",(char *) "pt", NULL
31328 };
31329
31330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31332 if (SWIG_arg_fail(1)) SWIG_fail;
31333 {
31334 arg2 = &temp2;
31335 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31336 }
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31340
31341 wxPyEndAllowThreads(__tstate);
31342 if (PyErr_Occurred()) SWIG_fail;
31343 }
31344 {
31345 wxPoint * resultptr;
31346 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31348 }
31349 return resultobj;
31350 fail:
31351 return NULL;
31352 }
31353
31354
31355 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31356 PyObject *resultobj = NULL;
31357 wxWindow *arg1 = (wxWindow *) 0 ;
31358 wxPoint *arg2 = 0 ;
31359 wxPoint result;
31360 wxPoint temp2 ;
31361 PyObject * obj0 = 0 ;
31362 PyObject * obj1 = 0 ;
31363 char *kwnames[] = {
31364 (char *) "self",(char *) "pt", NULL
31365 };
31366
31367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31369 if (SWIG_arg_fail(1)) SWIG_fail;
31370 {
31371 arg2 = &temp2;
31372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31373 }
31374 {
31375 PyThreadState* __tstate = wxPyBeginAllowThreads();
31376 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31377
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 {
31382 wxPoint * resultptr;
31383 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31385 }
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31393 PyObject *resultobj = NULL;
31394 wxWindow *arg1 = (wxWindow *) 0 ;
31395 int arg2 ;
31396 int arg3 ;
31397 wxHitTest result;
31398 PyObject * obj0 = 0 ;
31399 PyObject * obj1 = 0 ;
31400 PyObject * obj2 = 0 ;
31401 char *kwnames[] = {
31402 (char *) "self",(char *) "x",(char *) "y", NULL
31403 };
31404
31405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31407 if (SWIG_arg_fail(1)) SWIG_fail;
31408 {
31409 arg2 = static_cast<int >(SWIG_As_int(obj1));
31410 if (SWIG_arg_fail(2)) SWIG_fail;
31411 }
31412 {
31413 arg3 = static_cast<int >(SWIG_As_int(obj2));
31414 if (SWIG_arg_fail(3)) SWIG_fail;
31415 }
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31419
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_From_int((result));
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31431 PyObject *resultobj = NULL;
31432 wxWindow *arg1 = (wxWindow *) 0 ;
31433 wxPoint *arg2 = 0 ;
31434 wxHitTest result;
31435 wxPoint temp2 ;
31436 PyObject * obj0 = 0 ;
31437 PyObject * obj1 = 0 ;
31438 char *kwnames[] = {
31439 (char *) "self",(char *) "pt", NULL
31440 };
31441
31442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31444 if (SWIG_arg_fail(1)) SWIG_fail;
31445 {
31446 arg2 = &temp2;
31447 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31448 }
31449 {
31450 PyThreadState* __tstate = wxPyBeginAllowThreads();
31451 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31452
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_From_int((result));
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31464 PyObject *resultobj = NULL;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 long arg2 ;
31467 wxBorder result;
31468 PyObject * obj0 = 0 ;
31469 PyObject * obj1 = 0 ;
31470
31471 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31473 if (SWIG_arg_fail(1)) SWIG_fail;
31474 {
31475 arg2 = static_cast<long >(SWIG_As_long(obj1));
31476 if (SWIG_arg_fail(2)) SWIG_fail;
31477 }
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31481
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_From_int((result));
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31493 PyObject *resultobj = NULL;
31494 wxWindow *arg1 = (wxWindow *) 0 ;
31495 wxBorder result;
31496 PyObject * obj0 = 0 ;
31497
31498 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31500 if (SWIG_arg_fail(1)) SWIG_fail;
31501 {
31502 PyThreadState* __tstate = wxPyBeginAllowThreads();
31503 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31504
31505 wxPyEndAllowThreads(__tstate);
31506 if (PyErr_Occurred()) SWIG_fail;
31507 }
31508 resultobj = SWIG_From_int((result));
31509 return resultobj;
31510 fail:
31511 return NULL;
31512 }
31513
31514
31515 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31516 int argc;
31517 PyObject *argv[3];
31518 int ii;
31519
31520 argc = PyObject_Length(args);
31521 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31522 argv[ii] = PyTuple_GetItem(args,ii);
31523 }
31524 if (argc == 1) {
31525 int _v;
31526 {
31527 void *ptr;
31528 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31529 _v = 0;
31530 PyErr_Clear();
31531 } else {
31532 _v = 1;
31533 }
31534 }
31535 if (_v) {
31536 return _wrap_Window_GetBorder__SWIG_1(self,args);
31537 }
31538 }
31539 if (argc == 2) {
31540 int _v;
31541 {
31542 void *ptr;
31543 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31544 _v = 0;
31545 PyErr_Clear();
31546 } else {
31547 _v = 1;
31548 }
31549 }
31550 if (_v) {
31551 _v = SWIG_Check_long(argv[1]);
31552 if (_v) {
31553 return _wrap_Window_GetBorder__SWIG_0(self,args);
31554 }
31555 }
31556 }
31557
31558 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31559 return NULL;
31560 }
31561
31562
31563 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31564 PyObject *resultobj = NULL;
31565 wxWindow *arg1 = (wxWindow *) 0 ;
31566 long arg2 = (long) wxUPDATE_UI_NONE ;
31567 PyObject * obj0 = 0 ;
31568 PyObject * obj1 = 0 ;
31569 char *kwnames[] = {
31570 (char *) "self",(char *) "flags", NULL
31571 };
31572
31573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31575 if (SWIG_arg_fail(1)) SWIG_fail;
31576 if (obj1) {
31577 {
31578 arg2 = static_cast<long >(SWIG_As_long(obj1));
31579 if (SWIG_arg_fail(2)) SWIG_fail;
31580 }
31581 }
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 (arg1)->UpdateWindowUI(arg2);
31585
31586 wxPyEndAllowThreads(__tstate);
31587 if (PyErr_Occurred()) SWIG_fail;
31588 }
31589 Py_INCREF(Py_None); resultobj = Py_None;
31590 return resultobj;
31591 fail:
31592 return NULL;
31593 }
31594
31595
31596 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31597 PyObject *resultobj = NULL;
31598 wxWindow *arg1 = (wxWindow *) 0 ;
31599 wxMenu *arg2 = (wxMenu *) 0 ;
31600 int arg3 = (int) -1 ;
31601 int arg4 = (int) -1 ;
31602 bool result;
31603 PyObject * obj0 = 0 ;
31604 PyObject * obj1 = 0 ;
31605 PyObject * obj2 = 0 ;
31606 PyObject * obj3 = 0 ;
31607 char *kwnames[] = {
31608 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31609 };
31610
31611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31613 if (SWIG_arg_fail(1)) SWIG_fail;
31614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31615 if (SWIG_arg_fail(2)) SWIG_fail;
31616 if (obj2) {
31617 {
31618 arg3 = static_cast<int >(SWIG_As_int(obj2));
31619 if (SWIG_arg_fail(3)) SWIG_fail;
31620 }
31621 }
31622 if (obj3) {
31623 {
31624 arg4 = static_cast<int >(SWIG_As_int(obj3));
31625 if (SWIG_arg_fail(4)) SWIG_fail;
31626 }
31627 }
31628 {
31629 PyThreadState* __tstate = wxPyBeginAllowThreads();
31630 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31631
31632 wxPyEndAllowThreads(__tstate);
31633 if (PyErr_Occurred()) SWIG_fail;
31634 }
31635 {
31636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31637 }
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31645 PyObject *resultobj = NULL;
31646 wxWindow *arg1 = (wxWindow *) 0 ;
31647 wxMenu *arg2 = (wxMenu *) 0 ;
31648 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31649 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31650 bool result;
31651 wxPoint temp3 ;
31652 PyObject * obj0 = 0 ;
31653 PyObject * obj1 = 0 ;
31654 PyObject * obj2 = 0 ;
31655 char *kwnames[] = {
31656 (char *) "self",(char *) "menu",(char *) "pos", NULL
31657 };
31658
31659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31661 if (SWIG_arg_fail(1)) SWIG_fail;
31662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31663 if (SWIG_arg_fail(2)) SWIG_fail;
31664 if (obj2) {
31665 {
31666 arg3 = &temp3;
31667 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31668 }
31669 }
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31673
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 {
31678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31679 }
31680 return resultobj;
31681 fail:
31682 return NULL;
31683 }
31684
31685
31686 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31687 PyObject *resultobj = NULL;
31688 wxWindow *arg1 = (wxWindow *) 0 ;
31689 long result;
31690 PyObject * obj0 = 0 ;
31691 char *kwnames[] = {
31692 (char *) "self", NULL
31693 };
31694
31695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31697 if (SWIG_arg_fail(1)) SWIG_fail;
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 result = (long)wxWindow_GetHandle(arg1);
31701
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 {
31706 resultobj = SWIG_From_long(static_cast<long >(result));
31707 }
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31715 PyObject *resultobj = NULL;
31716 wxWindow *arg1 = (wxWindow *) 0 ;
31717 long arg2 ;
31718 PyObject * obj0 = 0 ;
31719 PyObject * obj1 = 0 ;
31720 char *kwnames[] = {
31721 (char *) "self",(char *) "handle", NULL
31722 };
31723
31724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31726 if (SWIG_arg_fail(1)) SWIG_fail;
31727 {
31728 arg2 = static_cast<long >(SWIG_As_long(obj1));
31729 if (SWIG_arg_fail(2)) SWIG_fail;
31730 }
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 wxWindow_AssociateHandle(arg1,arg2);
31734
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 Py_INCREF(Py_None); resultobj = Py_None;
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj = NULL;
31747 wxWindow *arg1 = (wxWindow *) 0 ;
31748 PyObject * obj0 = 0 ;
31749 char *kwnames[] = {
31750 (char *) "self", NULL
31751 };
31752
31753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31755 if (SWIG_arg_fail(1)) SWIG_fail;
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 (arg1)->DissociateHandle();
31759
31760 wxPyEndAllowThreads(__tstate);
31761 if (PyErr_Occurred()) SWIG_fail;
31762 }
31763 Py_INCREF(Py_None); resultobj = Py_None;
31764 return resultobj;
31765 fail:
31766 return NULL;
31767 }
31768
31769
31770 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31771 PyObject *resultobj = NULL;
31772 wxWindow *arg1 = (wxWindow *) 0 ;
31773 wxPaintEvent *arg2 = 0 ;
31774 PyObject * obj0 = 0 ;
31775 PyObject * obj1 = 0 ;
31776 char *kwnames[] = {
31777 (char *) "self",(char *) "event", NULL
31778 };
31779
31780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31782 if (SWIG_arg_fail(1)) SWIG_fail;
31783 {
31784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31785 if (SWIG_arg_fail(2)) SWIG_fail;
31786 if (arg2 == NULL) {
31787 SWIG_null_ref("wxPaintEvent");
31788 }
31789 if (SWIG_arg_fail(2)) SWIG_fail;
31790 }
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 (arg1)->OnPaint(*arg2);
31794
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 Py_INCREF(Py_None); resultobj = Py_None;
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj = NULL;
31807 wxWindow *arg1 = (wxWindow *) 0 ;
31808 int arg2 ;
31809 bool result;
31810 PyObject * obj0 = 0 ;
31811 PyObject * obj1 = 0 ;
31812 char *kwnames[] = {
31813 (char *) "self",(char *) "orient", NULL
31814 };
31815
31816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31818 if (SWIG_arg_fail(1)) SWIG_fail;
31819 {
31820 arg2 = static_cast<int >(SWIG_As_int(obj1));
31821 if (SWIG_arg_fail(2)) SWIG_fail;
31822 }
31823 {
31824 PyThreadState* __tstate = wxPyBeginAllowThreads();
31825 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31826
31827 wxPyEndAllowThreads(__tstate);
31828 if (PyErr_Occurred()) SWIG_fail;
31829 }
31830 {
31831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31832 }
31833 return resultobj;
31834 fail:
31835 return NULL;
31836 }
31837
31838
31839 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31840 PyObject *resultobj = NULL;
31841 wxWindow *arg1 = (wxWindow *) 0 ;
31842 int arg2 ;
31843 int arg3 ;
31844 int arg4 ;
31845 int arg5 ;
31846 bool arg6 = (bool) true ;
31847 PyObject * obj0 = 0 ;
31848 PyObject * obj1 = 0 ;
31849 PyObject * obj2 = 0 ;
31850 PyObject * obj3 = 0 ;
31851 PyObject * obj4 = 0 ;
31852 PyObject * obj5 = 0 ;
31853 char *kwnames[] = {
31854 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31855 };
31856
31857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31859 if (SWIG_arg_fail(1)) SWIG_fail;
31860 {
31861 arg2 = static_cast<int >(SWIG_As_int(obj1));
31862 if (SWIG_arg_fail(2)) SWIG_fail;
31863 }
31864 {
31865 arg3 = static_cast<int >(SWIG_As_int(obj2));
31866 if (SWIG_arg_fail(3)) SWIG_fail;
31867 }
31868 {
31869 arg4 = static_cast<int >(SWIG_As_int(obj3));
31870 if (SWIG_arg_fail(4)) SWIG_fail;
31871 }
31872 {
31873 arg5 = static_cast<int >(SWIG_As_int(obj4));
31874 if (SWIG_arg_fail(5)) SWIG_fail;
31875 }
31876 if (obj5) {
31877 {
31878 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31879 if (SWIG_arg_fail(6)) SWIG_fail;
31880 }
31881 }
31882 {
31883 PyThreadState* __tstate = wxPyBeginAllowThreads();
31884 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31885
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 Py_INCREF(Py_None); resultobj = Py_None;
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj = NULL;
31898 wxWindow *arg1 = (wxWindow *) 0 ;
31899 int arg2 ;
31900 int arg3 ;
31901 bool arg4 = (bool) true ;
31902 PyObject * obj0 = 0 ;
31903 PyObject * obj1 = 0 ;
31904 PyObject * obj2 = 0 ;
31905 PyObject * obj3 = 0 ;
31906 char *kwnames[] = {
31907 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31908 };
31909
31910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31912 if (SWIG_arg_fail(1)) SWIG_fail;
31913 {
31914 arg2 = static_cast<int >(SWIG_As_int(obj1));
31915 if (SWIG_arg_fail(2)) SWIG_fail;
31916 }
31917 {
31918 arg3 = static_cast<int >(SWIG_As_int(obj2));
31919 if (SWIG_arg_fail(3)) SWIG_fail;
31920 }
31921 if (obj3) {
31922 {
31923 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31924 if (SWIG_arg_fail(4)) SWIG_fail;
31925 }
31926 }
31927 {
31928 PyThreadState* __tstate = wxPyBeginAllowThreads();
31929 (arg1)->SetScrollPos(arg2,arg3,arg4);
31930
31931 wxPyEndAllowThreads(__tstate);
31932 if (PyErr_Occurred()) SWIG_fail;
31933 }
31934 Py_INCREF(Py_None); resultobj = Py_None;
31935 return resultobj;
31936 fail:
31937 return NULL;
31938 }
31939
31940
31941 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31942 PyObject *resultobj = NULL;
31943 wxWindow *arg1 = (wxWindow *) 0 ;
31944 int arg2 ;
31945 int result;
31946 PyObject * obj0 = 0 ;
31947 PyObject * obj1 = 0 ;
31948 char *kwnames[] = {
31949 (char *) "self",(char *) "orientation", NULL
31950 };
31951
31952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31954 if (SWIG_arg_fail(1)) SWIG_fail;
31955 {
31956 arg2 = static_cast<int >(SWIG_As_int(obj1));
31957 if (SWIG_arg_fail(2)) SWIG_fail;
31958 }
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31962
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 {
31967 resultobj = SWIG_From_int(static_cast<int >(result));
31968 }
31969 return resultobj;
31970 fail:
31971 return NULL;
31972 }
31973
31974
31975 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31976 PyObject *resultobj = NULL;
31977 wxWindow *arg1 = (wxWindow *) 0 ;
31978 int arg2 ;
31979 int result;
31980 PyObject * obj0 = 0 ;
31981 PyObject * obj1 = 0 ;
31982 char *kwnames[] = {
31983 (char *) "self",(char *) "orientation", NULL
31984 };
31985
31986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31988 if (SWIG_arg_fail(1)) SWIG_fail;
31989 {
31990 arg2 = static_cast<int >(SWIG_As_int(obj1));
31991 if (SWIG_arg_fail(2)) SWIG_fail;
31992 }
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31996
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 {
32001 resultobj = SWIG_From_int(static_cast<int >(result));
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32010 PyObject *resultobj = NULL;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 int arg2 ;
32013 int result;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 char *kwnames[] = {
32017 (char *) "self",(char *) "orientation", NULL
32018 };
32019
32020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32022 if (SWIG_arg_fail(1)) SWIG_fail;
32023 {
32024 arg2 = static_cast<int >(SWIG_As_int(obj1));
32025 if (SWIG_arg_fail(2)) SWIG_fail;
32026 }
32027 {
32028 PyThreadState* __tstate = wxPyBeginAllowThreads();
32029 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32030
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 {
32035 resultobj = SWIG_From_int(static_cast<int >(result));
32036 }
32037 return resultobj;
32038 fail:
32039 return NULL;
32040 }
32041
32042
32043 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32044 PyObject *resultobj = NULL;
32045 wxWindow *arg1 = (wxWindow *) 0 ;
32046 int arg2 ;
32047 int arg3 ;
32048 wxRect *arg4 = (wxRect *) NULL ;
32049 PyObject * obj0 = 0 ;
32050 PyObject * obj1 = 0 ;
32051 PyObject * obj2 = 0 ;
32052 PyObject * obj3 = 0 ;
32053 char *kwnames[] = {
32054 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32055 };
32056
32057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32059 if (SWIG_arg_fail(1)) SWIG_fail;
32060 {
32061 arg2 = static_cast<int >(SWIG_As_int(obj1));
32062 if (SWIG_arg_fail(2)) SWIG_fail;
32063 }
32064 {
32065 arg3 = static_cast<int >(SWIG_As_int(obj2));
32066 if (SWIG_arg_fail(3)) SWIG_fail;
32067 }
32068 if (obj3) {
32069 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32070 if (SWIG_arg_fail(4)) SWIG_fail;
32071 }
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32075
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 Py_INCREF(Py_None); resultobj = Py_None;
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = NULL;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 int arg2 ;
32090 bool result;
32091 PyObject * obj0 = 0 ;
32092 PyObject * obj1 = 0 ;
32093 char *kwnames[] = {
32094 (char *) "self",(char *) "lines", NULL
32095 };
32096
32097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32099 if (SWIG_arg_fail(1)) SWIG_fail;
32100 {
32101 arg2 = static_cast<int >(SWIG_As_int(obj1));
32102 if (SWIG_arg_fail(2)) SWIG_fail;
32103 }
32104 {
32105 PyThreadState* __tstate = wxPyBeginAllowThreads();
32106 result = (bool)(arg1)->ScrollLines(arg2);
32107
32108 wxPyEndAllowThreads(__tstate);
32109 if (PyErr_Occurred()) SWIG_fail;
32110 }
32111 {
32112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32113 }
32114 return resultobj;
32115 fail:
32116 return NULL;
32117 }
32118
32119
32120 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32121 PyObject *resultobj = NULL;
32122 wxWindow *arg1 = (wxWindow *) 0 ;
32123 int arg2 ;
32124 bool result;
32125 PyObject * obj0 = 0 ;
32126 PyObject * obj1 = 0 ;
32127 char *kwnames[] = {
32128 (char *) "self",(char *) "pages", NULL
32129 };
32130
32131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32133 if (SWIG_arg_fail(1)) SWIG_fail;
32134 {
32135 arg2 = static_cast<int >(SWIG_As_int(obj1));
32136 if (SWIG_arg_fail(2)) SWIG_fail;
32137 }
32138 {
32139 PyThreadState* __tstate = wxPyBeginAllowThreads();
32140 result = (bool)(arg1)->ScrollPages(arg2);
32141
32142 wxPyEndAllowThreads(__tstate);
32143 if (PyErr_Occurred()) SWIG_fail;
32144 }
32145 {
32146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32147 }
32148 return resultobj;
32149 fail:
32150 return NULL;
32151 }
32152
32153
32154 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32155 PyObject *resultobj = NULL;
32156 wxWindow *arg1 = (wxWindow *) 0 ;
32157 bool result;
32158 PyObject * obj0 = 0 ;
32159 char *kwnames[] = {
32160 (char *) "self", NULL
32161 };
32162
32163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32165 if (SWIG_arg_fail(1)) SWIG_fail;
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)(arg1)->LineUp();
32169
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 {
32174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32175 }
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32183 PyObject *resultobj = NULL;
32184 wxWindow *arg1 = (wxWindow *) 0 ;
32185 bool result;
32186 PyObject * obj0 = 0 ;
32187 char *kwnames[] = {
32188 (char *) "self", NULL
32189 };
32190
32191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32193 if (SWIG_arg_fail(1)) SWIG_fail;
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = (bool)(arg1)->LineDown();
32197
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 {
32202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32203 }
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj = NULL;
32212 wxWindow *arg1 = (wxWindow *) 0 ;
32213 bool result;
32214 PyObject * obj0 = 0 ;
32215 char *kwnames[] = {
32216 (char *) "self", NULL
32217 };
32218
32219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32221 if (SWIG_arg_fail(1)) SWIG_fail;
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (bool)(arg1)->PageUp();
32225
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 {
32230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32231 }
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32239 PyObject *resultobj = NULL;
32240 wxWindow *arg1 = (wxWindow *) 0 ;
32241 bool result;
32242 PyObject * obj0 = 0 ;
32243 char *kwnames[] = {
32244 (char *) "self", NULL
32245 };
32246
32247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32249 if (SWIG_arg_fail(1)) SWIG_fail;
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = (bool)(arg1)->PageDown();
32253
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32259 }
32260 return resultobj;
32261 fail:
32262 return NULL;
32263 }
32264
32265
32266 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32267 PyObject *resultobj = NULL;
32268 wxWindow *arg1 = (wxWindow *) 0 ;
32269 wxString *arg2 = 0 ;
32270 bool temp2 = false ;
32271 PyObject * obj0 = 0 ;
32272 PyObject * obj1 = 0 ;
32273 char *kwnames[] = {
32274 (char *) "self",(char *) "text", NULL
32275 };
32276
32277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32279 if (SWIG_arg_fail(1)) SWIG_fail;
32280 {
32281 arg2 = wxString_in_helper(obj1);
32282 if (arg2 == NULL) SWIG_fail;
32283 temp2 = true;
32284 }
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 (arg1)->SetHelpText((wxString const &)*arg2);
32288
32289 wxPyEndAllowThreads(__tstate);
32290 if (PyErr_Occurred()) SWIG_fail;
32291 }
32292 Py_INCREF(Py_None); resultobj = Py_None;
32293 {
32294 if (temp2)
32295 delete arg2;
32296 }
32297 return resultobj;
32298 fail:
32299 {
32300 if (temp2)
32301 delete arg2;
32302 }
32303 return NULL;
32304 }
32305
32306
32307 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32308 PyObject *resultobj = NULL;
32309 wxWindow *arg1 = (wxWindow *) 0 ;
32310 wxString *arg2 = 0 ;
32311 bool temp2 = false ;
32312 PyObject * obj0 = 0 ;
32313 PyObject * obj1 = 0 ;
32314 char *kwnames[] = {
32315 (char *) "self",(char *) "text", NULL
32316 };
32317
32318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32320 if (SWIG_arg_fail(1)) SWIG_fail;
32321 {
32322 arg2 = wxString_in_helper(obj1);
32323 if (arg2 == NULL) SWIG_fail;
32324 temp2 = true;
32325 }
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32329
32330 wxPyEndAllowThreads(__tstate);
32331 if (PyErr_Occurred()) SWIG_fail;
32332 }
32333 Py_INCREF(Py_None); resultobj = Py_None;
32334 {
32335 if (temp2)
32336 delete arg2;
32337 }
32338 return resultobj;
32339 fail:
32340 {
32341 if (temp2)
32342 delete arg2;
32343 }
32344 return NULL;
32345 }
32346
32347
32348 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32349 PyObject *resultobj = NULL;
32350 wxWindow *arg1 = (wxWindow *) 0 ;
32351 wxString result;
32352 PyObject * obj0 = 0 ;
32353 char *kwnames[] = {
32354 (char *) "self", NULL
32355 };
32356
32357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32359 if (SWIG_arg_fail(1)) SWIG_fail;
32360 {
32361 PyThreadState* __tstate = wxPyBeginAllowThreads();
32362 result = ((wxWindow const *)arg1)->GetHelpText();
32363
32364 wxPyEndAllowThreads(__tstate);
32365 if (PyErr_Occurred()) SWIG_fail;
32366 }
32367 {
32368 #if wxUSE_UNICODE
32369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32370 #else
32371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32372 #endif
32373 }
32374 return resultobj;
32375 fail:
32376 return NULL;
32377 }
32378
32379
32380 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32381 PyObject *resultobj = NULL;
32382 wxWindow *arg1 = (wxWindow *) 0 ;
32383 wxString *arg2 = 0 ;
32384 bool temp2 = false ;
32385 PyObject * obj0 = 0 ;
32386 PyObject * obj1 = 0 ;
32387 char *kwnames[] = {
32388 (char *) "self",(char *) "tip", NULL
32389 };
32390
32391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32393 if (SWIG_arg_fail(1)) SWIG_fail;
32394 {
32395 arg2 = wxString_in_helper(obj1);
32396 if (arg2 == NULL) SWIG_fail;
32397 temp2 = true;
32398 }
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 (arg1)->SetToolTip((wxString const &)*arg2);
32402
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 Py_INCREF(Py_None); resultobj = Py_None;
32407 {
32408 if (temp2)
32409 delete arg2;
32410 }
32411 return resultobj;
32412 fail:
32413 {
32414 if (temp2)
32415 delete arg2;
32416 }
32417 return NULL;
32418 }
32419
32420
32421 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32422 PyObject *resultobj = NULL;
32423 wxWindow *arg1 = (wxWindow *) 0 ;
32424 wxToolTip *arg2 = (wxToolTip *) 0 ;
32425 PyObject * obj0 = 0 ;
32426 PyObject * obj1 = 0 ;
32427 char *kwnames[] = {
32428 (char *) "self",(char *) "tip", NULL
32429 };
32430
32431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32433 if (SWIG_arg_fail(1)) SWIG_fail;
32434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32435 if (SWIG_arg_fail(2)) SWIG_fail;
32436 {
32437 PyThreadState* __tstate = wxPyBeginAllowThreads();
32438 (arg1)->SetToolTip(arg2);
32439
32440 wxPyEndAllowThreads(__tstate);
32441 if (PyErr_Occurred()) SWIG_fail;
32442 }
32443 Py_INCREF(Py_None); resultobj = Py_None;
32444 return resultobj;
32445 fail:
32446 return NULL;
32447 }
32448
32449
32450 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32451 PyObject *resultobj = NULL;
32452 wxWindow *arg1 = (wxWindow *) 0 ;
32453 wxToolTip *result;
32454 PyObject * obj0 = 0 ;
32455 char *kwnames[] = {
32456 (char *) "self", NULL
32457 };
32458
32459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32461 if (SWIG_arg_fail(1)) SWIG_fail;
32462 {
32463 PyThreadState* __tstate = wxPyBeginAllowThreads();
32464 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32465
32466 wxPyEndAllowThreads(__tstate);
32467 if (PyErr_Occurred()) SWIG_fail;
32468 }
32469 {
32470 resultobj = wxPyMake_wxObject(result, 0);
32471 }
32472 return resultobj;
32473 fail:
32474 return NULL;
32475 }
32476
32477
32478 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32479 PyObject *resultobj = NULL;
32480 wxWindow *arg1 = (wxWindow *) 0 ;
32481 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32482 PyObject * obj0 = 0 ;
32483 PyObject * obj1 = 0 ;
32484 char *kwnames[] = {
32485 (char *) "self",(char *) "dropTarget", NULL
32486 };
32487
32488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32490 if (SWIG_arg_fail(1)) SWIG_fail;
32491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32492 if (SWIG_arg_fail(2)) SWIG_fail;
32493 {
32494 PyThreadState* __tstate = wxPyBeginAllowThreads();
32495 (arg1)->SetDropTarget(arg2);
32496
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 Py_INCREF(Py_None); resultobj = Py_None;
32501 return resultobj;
32502 fail:
32503 return NULL;
32504 }
32505
32506
32507 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32508 PyObject *resultobj = NULL;
32509 wxWindow *arg1 = (wxWindow *) 0 ;
32510 wxPyDropTarget *result;
32511 PyObject * obj0 = 0 ;
32512 char *kwnames[] = {
32513 (char *) "self", NULL
32514 };
32515
32516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32518 if (SWIG_arg_fail(1)) SWIG_fail;
32519 {
32520 PyThreadState* __tstate = wxPyBeginAllowThreads();
32521 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32522
32523 wxPyEndAllowThreads(__tstate);
32524 if (PyErr_Occurred()) SWIG_fail;
32525 }
32526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32534 PyObject *resultobj = NULL;
32535 wxWindow *arg1 = (wxWindow *) 0 ;
32536 bool arg2 ;
32537 PyObject * obj0 = 0 ;
32538 PyObject * obj1 = 0 ;
32539 char *kwnames[] = {
32540 (char *) "self",(char *) "accept", NULL
32541 };
32542
32543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32545 if (SWIG_arg_fail(1)) SWIG_fail;
32546 {
32547 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32548 if (SWIG_arg_fail(2)) SWIG_fail;
32549 }
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 (arg1)->DragAcceptFiles(arg2);
32553
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 Py_INCREF(Py_None); resultobj = Py_None;
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = NULL;
32566 wxWindow *arg1 = (wxWindow *) 0 ;
32567 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32568 PyObject * obj0 = 0 ;
32569 PyObject * obj1 = 0 ;
32570 char *kwnames[] = {
32571 (char *) "self",(char *) "constraints", NULL
32572 };
32573
32574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32576 if (SWIG_arg_fail(1)) SWIG_fail;
32577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32578 if (SWIG_arg_fail(2)) SWIG_fail;
32579 {
32580 PyThreadState* __tstate = wxPyBeginAllowThreads();
32581 (arg1)->SetConstraints(arg2);
32582
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 Py_INCREF(Py_None); resultobj = Py_None;
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj = NULL;
32595 wxWindow *arg1 = (wxWindow *) 0 ;
32596 wxLayoutConstraints *result;
32597 PyObject * obj0 = 0 ;
32598 char *kwnames[] = {
32599 (char *) "self", NULL
32600 };
32601
32602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32604 if (SWIG_arg_fail(1)) SWIG_fail;
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32608
32609 wxPyEndAllowThreads(__tstate);
32610 if (PyErr_Occurred()) SWIG_fail;
32611 }
32612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32613 return resultobj;
32614 fail:
32615 return NULL;
32616 }
32617
32618
32619 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32620 PyObject *resultobj = NULL;
32621 wxWindow *arg1 = (wxWindow *) 0 ;
32622 bool arg2 ;
32623 PyObject * obj0 = 0 ;
32624 PyObject * obj1 = 0 ;
32625 char *kwnames[] = {
32626 (char *) "self",(char *) "autoLayout", NULL
32627 };
32628
32629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32631 if (SWIG_arg_fail(1)) SWIG_fail;
32632 {
32633 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32634 if (SWIG_arg_fail(2)) SWIG_fail;
32635 }
32636 {
32637 PyThreadState* __tstate = wxPyBeginAllowThreads();
32638 (arg1)->SetAutoLayout(arg2);
32639
32640 wxPyEndAllowThreads(__tstate);
32641 if (PyErr_Occurred()) SWIG_fail;
32642 }
32643 Py_INCREF(Py_None); resultobj = Py_None;
32644 return resultobj;
32645 fail:
32646 return NULL;
32647 }
32648
32649
32650 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32651 PyObject *resultobj = NULL;
32652 wxWindow *arg1 = (wxWindow *) 0 ;
32653 bool result;
32654 PyObject * obj0 = 0 ;
32655 char *kwnames[] = {
32656 (char *) "self", NULL
32657 };
32658
32659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32661 if (SWIG_arg_fail(1)) SWIG_fail;
32662 {
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32665
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 {
32670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32671 }
32672 return resultobj;
32673 fail:
32674 return NULL;
32675 }
32676
32677
32678 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32679 PyObject *resultobj = NULL;
32680 wxWindow *arg1 = (wxWindow *) 0 ;
32681 bool result;
32682 PyObject * obj0 = 0 ;
32683 char *kwnames[] = {
32684 (char *) "self", NULL
32685 };
32686
32687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32689 if (SWIG_arg_fail(1)) SWIG_fail;
32690 {
32691 PyThreadState* __tstate = wxPyBeginAllowThreads();
32692 result = (bool)(arg1)->Layout();
32693
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 {
32698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32699 }
32700 return resultobj;
32701 fail:
32702 return NULL;
32703 }
32704
32705
32706 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32707 PyObject *resultobj = NULL;
32708 wxWindow *arg1 = (wxWindow *) 0 ;
32709 wxSizer *arg2 = (wxSizer *) 0 ;
32710 bool arg3 = (bool) true ;
32711 PyObject * obj0 = 0 ;
32712 PyObject * obj1 = 0 ;
32713 PyObject * obj2 = 0 ;
32714 char *kwnames[] = {
32715 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32716 };
32717
32718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32720 if (SWIG_arg_fail(1)) SWIG_fail;
32721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32722 if (SWIG_arg_fail(2)) SWIG_fail;
32723 if (obj2) {
32724 {
32725 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32726 if (SWIG_arg_fail(3)) SWIG_fail;
32727 }
32728 }
32729 {
32730 PyThreadState* __tstate = wxPyBeginAllowThreads();
32731 (arg1)->SetSizer(arg2,arg3);
32732
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 Py_INCREF(Py_None); resultobj = Py_None;
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj = NULL;
32745 wxWindow *arg1 = (wxWindow *) 0 ;
32746 wxSizer *arg2 = (wxSizer *) 0 ;
32747 bool arg3 = (bool) true ;
32748 PyObject * obj0 = 0 ;
32749 PyObject * obj1 = 0 ;
32750 PyObject * obj2 = 0 ;
32751 char *kwnames[] = {
32752 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32753 };
32754
32755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32757 if (SWIG_arg_fail(1)) SWIG_fail;
32758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32759 if (SWIG_arg_fail(2)) SWIG_fail;
32760 if (obj2) {
32761 {
32762 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32763 if (SWIG_arg_fail(3)) SWIG_fail;
32764 }
32765 }
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 (arg1)->SetSizerAndFit(arg2,arg3);
32769
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 Py_INCREF(Py_None); resultobj = Py_None;
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32781 PyObject *resultobj = NULL;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 wxSizer *result;
32784 PyObject * obj0 = 0 ;
32785 char *kwnames[] = {
32786 (char *) "self", NULL
32787 };
32788
32789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32791 if (SWIG_arg_fail(1)) SWIG_fail;
32792 {
32793 PyThreadState* __tstate = wxPyBeginAllowThreads();
32794 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32795
32796 wxPyEndAllowThreads(__tstate);
32797 if (PyErr_Occurred()) SWIG_fail;
32798 }
32799 {
32800 resultobj = wxPyMake_wxObject(result, 0);
32801 }
32802 return resultobj;
32803 fail:
32804 return NULL;
32805 }
32806
32807
32808 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32809 PyObject *resultobj = NULL;
32810 wxWindow *arg1 = (wxWindow *) 0 ;
32811 wxSizer *arg2 = (wxSizer *) 0 ;
32812 PyObject * obj0 = 0 ;
32813 PyObject * obj1 = 0 ;
32814 char *kwnames[] = {
32815 (char *) "self",(char *) "sizer", NULL
32816 };
32817
32818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32820 if (SWIG_arg_fail(1)) SWIG_fail;
32821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32822 if (SWIG_arg_fail(2)) SWIG_fail;
32823 {
32824 PyThreadState* __tstate = wxPyBeginAllowThreads();
32825 (arg1)->SetContainingSizer(arg2);
32826
32827 wxPyEndAllowThreads(__tstate);
32828 if (PyErr_Occurred()) SWIG_fail;
32829 }
32830 Py_INCREF(Py_None); resultobj = Py_None;
32831 return resultobj;
32832 fail:
32833 return NULL;
32834 }
32835
32836
32837 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32838 PyObject *resultobj = NULL;
32839 wxWindow *arg1 = (wxWindow *) 0 ;
32840 wxSizer *result;
32841 PyObject * obj0 = 0 ;
32842 char *kwnames[] = {
32843 (char *) "self", NULL
32844 };
32845
32846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32848 if (SWIG_arg_fail(1)) SWIG_fail;
32849 {
32850 PyThreadState* __tstate = wxPyBeginAllowThreads();
32851 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32852
32853 wxPyEndAllowThreads(__tstate);
32854 if (PyErr_Occurred()) SWIG_fail;
32855 }
32856 {
32857 resultobj = wxPyMake_wxObject(result, 0);
32858 }
32859 return resultobj;
32860 fail:
32861 return NULL;
32862 }
32863
32864
32865 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj = NULL;
32867 wxWindow *arg1 = (wxWindow *) 0 ;
32868 PyObject * obj0 = 0 ;
32869 char *kwnames[] = {
32870 (char *) "self", NULL
32871 };
32872
32873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32875 if (SWIG_arg_fail(1)) SWIG_fail;
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 (arg1)->InheritAttributes();
32879
32880 wxPyEndAllowThreads(__tstate);
32881 if (PyErr_Occurred()) SWIG_fail;
32882 }
32883 Py_INCREF(Py_None); resultobj = Py_None;
32884 return resultobj;
32885 fail:
32886 return NULL;
32887 }
32888
32889
32890 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32891 PyObject *resultobj = NULL;
32892 wxWindow *arg1 = (wxWindow *) 0 ;
32893 bool result;
32894 PyObject * obj0 = 0 ;
32895 char *kwnames[] = {
32896 (char *) "self", NULL
32897 };
32898
32899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32901 if (SWIG_arg_fail(1)) SWIG_fail;
32902 {
32903 PyThreadState* __tstate = wxPyBeginAllowThreads();
32904 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32905
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 {
32910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32911 }
32912 return resultobj;
32913 fail:
32914 return NULL;
32915 }
32916
32917
32918 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32919 PyObject *obj;
32920 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32921 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32922 Py_INCREF(obj);
32923 return Py_BuildValue((char *)"");
32924 }
32925 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32926 PyObject *resultobj = NULL;
32927 long arg1 ;
32928 wxWindow *arg2 = (wxWindow *) NULL ;
32929 wxWindow *result;
32930 PyObject * obj0 = 0 ;
32931 PyObject * obj1 = 0 ;
32932 char *kwnames[] = {
32933 (char *) "id",(char *) "parent", NULL
32934 };
32935
32936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32937 {
32938 arg1 = static_cast<long >(SWIG_As_long(obj0));
32939 if (SWIG_arg_fail(1)) SWIG_fail;
32940 }
32941 if (obj1) {
32942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32943 if (SWIG_arg_fail(2)) SWIG_fail;
32944 }
32945 {
32946 if (!wxPyCheckForApp()) SWIG_fail;
32947 PyThreadState* __tstate = wxPyBeginAllowThreads();
32948 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32949
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 {
32954 resultobj = wxPyMake_wxObject(result, 0);
32955 }
32956 return resultobj;
32957 fail:
32958 return NULL;
32959 }
32960
32961
32962 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32963 PyObject *resultobj = NULL;
32964 wxString *arg1 = 0 ;
32965 wxWindow *arg2 = (wxWindow *) NULL ;
32966 wxWindow *result;
32967 bool temp1 = false ;
32968 PyObject * obj0 = 0 ;
32969 PyObject * obj1 = 0 ;
32970 char *kwnames[] = {
32971 (char *) "name",(char *) "parent", NULL
32972 };
32973
32974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32975 {
32976 arg1 = wxString_in_helper(obj0);
32977 if (arg1 == NULL) SWIG_fail;
32978 temp1 = true;
32979 }
32980 if (obj1) {
32981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32982 if (SWIG_arg_fail(2)) SWIG_fail;
32983 }
32984 {
32985 if (!wxPyCheckForApp()) SWIG_fail;
32986 PyThreadState* __tstate = wxPyBeginAllowThreads();
32987 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32988
32989 wxPyEndAllowThreads(__tstate);
32990 if (PyErr_Occurred()) SWIG_fail;
32991 }
32992 {
32993 resultobj = wxPyMake_wxObject(result, 0);
32994 }
32995 {
32996 if (temp1)
32997 delete arg1;
32998 }
32999 return resultobj;
33000 fail:
33001 {
33002 if (temp1)
33003 delete arg1;
33004 }
33005 return NULL;
33006 }
33007
33008
33009 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33010 PyObject *resultobj = NULL;
33011 wxString *arg1 = 0 ;
33012 wxWindow *arg2 = (wxWindow *) NULL ;
33013 wxWindow *result;
33014 bool temp1 = false ;
33015 PyObject * obj0 = 0 ;
33016 PyObject * obj1 = 0 ;
33017 char *kwnames[] = {
33018 (char *) "label",(char *) "parent", NULL
33019 };
33020
33021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33022 {
33023 arg1 = wxString_in_helper(obj0);
33024 if (arg1 == NULL) SWIG_fail;
33025 temp1 = true;
33026 }
33027 if (obj1) {
33028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33029 if (SWIG_arg_fail(2)) SWIG_fail;
33030 }
33031 {
33032 if (!wxPyCheckForApp()) SWIG_fail;
33033 PyThreadState* __tstate = wxPyBeginAllowThreads();
33034 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33035
33036 wxPyEndAllowThreads(__tstate);
33037 if (PyErr_Occurred()) SWIG_fail;
33038 }
33039 {
33040 resultobj = wxPyMake_wxObject(result, 0);
33041 }
33042 {
33043 if (temp1)
33044 delete arg1;
33045 }
33046 return resultobj;
33047 fail:
33048 {
33049 if (temp1)
33050 delete arg1;
33051 }
33052 return NULL;
33053 }
33054
33055
33056 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33057 PyObject *resultobj = NULL;
33058 wxWindow *arg1 = (wxWindow *) 0 ;
33059 unsigned long arg2 ;
33060 wxWindow *result;
33061 PyObject * obj0 = 0 ;
33062 PyObject * obj1 = 0 ;
33063 char *kwnames[] = {
33064 (char *) "parent",(char *) "_hWnd", NULL
33065 };
33066
33067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33069 if (SWIG_arg_fail(1)) SWIG_fail;
33070 {
33071 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33072 if (SWIG_arg_fail(2)) SWIG_fail;
33073 }
33074 {
33075 PyThreadState* __tstate = wxPyBeginAllowThreads();
33076 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33077
33078 wxPyEndAllowThreads(__tstate);
33079 if (PyErr_Occurred()) SWIG_fail;
33080 }
33081 {
33082 resultobj = wxPyMake_wxObject(result, 0);
33083 }
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj = NULL;
33092 PyObject *result;
33093 char *kwnames[] = {
33094 NULL
33095 };
33096
33097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (PyObject *)GetTopLevelWindows();
33101
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 resultobj = result;
33106 return resultobj;
33107 fail:
33108 return NULL;
33109 }
33110
33111
33112 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33113 PyObject *resultobj = NULL;
33114 wxValidator *result;
33115 char *kwnames[] = {
33116 NULL
33117 };
33118
33119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33120 {
33121 PyThreadState* __tstate = wxPyBeginAllowThreads();
33122 result = (wxValidator *)new wxValidator();
33123
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33128 return resultobj;
33129 fail:
33130 return NULL;
33131 }
33132
33133
33134 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33135 PyObject *resultobj = NULL;
33136 wxValidator *arg1 = (wxValidator *) 0 ;
33137 wxValidator *result;
33138 PyObject * obj0 = 0 ;
33139 char *kwnames[] = {
33140 (char *) "self", NULL
33141 };
33142
33143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33145 if (SWIG_arg_fail(1)) SWIG_fail;
33146 {
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = (wxValidator *)(arg1)->Clone();
33149
33150 wxPyEndAllowThreads(__tstate);
33151 if (PyErr_Occurred()) SWIG_fail;
33152 }
33153 {
33154 resultobj = wxPyMake_wxObject(result, 0);
33155 }
33156 return resultobj;
33157 fail:
33158 return NULL;
33159 }
33160
33161
33162 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33163 PyObject *resultobj = NULL;
33164 wxValidator *arg1 = (wxValidator *) 0 ;
33165 wxWindow *arg2 = (wxWindow *) 0 ;
33166 bool result;
33167 PyObject * obj0 = 0 ;
33168 PyObject * obj1 = 0 ;
33169 char *kwnames[] = {
33170 (char *) "self",(char *) "parent", NULL
33171 };
33172
33173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33175 if (SWIG_arg_fail(1)) SWIG_fail;
33176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33177 if (SWIG_arg_fail(2)) SWIG_fail;
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 result = (bool)(arg1)->Validate(arg2);
33181
33182 wxPyEndAllowThreads(__tstate);
33183 if (PyErr_Occurred()) SWIG_fail;
33184 }
33185 {
33186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33187 }
33188 return resultobj;
33189 fail:
33190 return NULL;
33191 }
33192
33193
33194 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33195 PyObject *resultobj = NULL;
33196 wxValidator *arg1 = (wxValidator *) 0 ;
33197 bool result;
33198 PyObject * obj0 = 0 ;
33199 char *kwnames[] = {
33200 (char *) "self", NULL
33201 };
33202
33203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33205 if (SWIG_arg_fail(1)) SWIG_fail;
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 result = (bool)(arg1)->TransferToWindow();
33209
33210 wxPyEndAllowThreads(__tstate);
33211 if (PyErr_Occurred()) SWIG_fail;
33212 }
33213 {
33214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33215 }
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33223 PyObject *resultobj = NULL;
33224 wxValidator *arg1 = (wxValidator *) 0 ;
33225 bool result;
33226 PyObject * obj0 = 0 ;
33227 char *kwnames[] = {
33228 (char *) "self", NULL
33229 };
33230
33231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33233 if (SWIG_arg_fail(1)) SWIG_fail;
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 result = (bool)(arg1)->TransferFromWindow();
33237
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 {
33242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33243 }
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33251 PyObject *resultobj = NULL;
33252 wxValidator *arg1 = (wxValidator *) 0 ;
33253 wxWindow *result;
33254 PyObject * obj0 = 0 ;
33255 char *kwnames[] = {
33256 (char *) "self", NULL
33257 };
33258
33259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33261 if (SWIG_arg_fail(1)) SWIG_fail;
33262 {
33263 PyThreadState* __tstate = wxPyBeginAllowThreads();
33264 result = (wxWindow *)(arg1)->GetWindow();
33265
33266 wxPyEndAllowThreads(__tstate);
33267 if (PyErr_Occurred()) SWIG_fail;
33268 }
33269 {
33270 resultobj = wxPyMake_wxObject(result, 0);
33271 }
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33279 PyObject *resultobj = NULL;
33280 wxValidator *arg1 = (wxValidator *) 0 ;
33281 wxWindow *arg2 = (wxWindow *) 0 ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 char *kwnames[] = {
33285 (char *) "self",(char *) "window", NULL
33286 };
33287
33288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33290 if (SWIG_arg_fail(1)) SWIG_fail;
33291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33292 if (SWIG_arg_fail(2)) SWIG_fail;
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 (arg1)->SetWindow(arg2);
33296
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 Py_INCREF(Py_None); resultobj = Py_None;
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33308 PyObject *resultobj = NULL;
33309 bool result;
33310 char *kwnames[] = {
33311 NULL
33312 };
33313
33314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = (bool)wxValidator::IsSilent();
33318
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 {
33323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33324 }
33325 return resultobj;
33326 fail:
33327 return NULL;
33328 }
33329
33330
33331 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33332 PyObject *resultobj = NULL;
33333 int arg1 = (int) true ;
33334 PyObject * obj0 = 0 ;
33335 char *kwnames[] = {
33336 (char *) "doIt", NULL
33337 };
33338
33339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33340 if (obj0) {
33341 {
33342 arg1 = static_cast<int >(SWIG_As_int(obj0));
33343 if (SWIG_arg_fail(1)) SWIG_fail;
33344 }
33345 }
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 wxValidator::SetBellOnError(arg1);
33349
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 Py_INCREF(Py_None); resultobj = Py_None;
33354 return resultobj;
33355 fail:
33356 return NULL;
33357 }
33358
33359
33360 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33361 PyObject *obj;
33362 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33363 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33364 Py_INCREF(obj);
33365 return Py_BuildValue((char *)"");
33366 }
33367 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33368 PyObject *resultobj = NULL;
33369 wxPyValidator *result;
33370 char *kwnames[] = {
33371 NULL
33372 };
33373
33374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33375 {
33376 PyThreadState* __tstate = wxPyBeginAllowThreads();
33377 result = (wxPyValidator *)new wxPyValidator();
33378
33379 wxPyEndAllowThreads(__tstate);
33380 if (PyErr_Occurred()) SWIG_fail;
33381 }
33382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33383 return resultobj;
33384 fail:
33385 return NULL;
33386 }
33387
33388
33389 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33390 PyObject *resultobj = NULL;
33391 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33392 PyObject *arg2 = (PyObject *) 0 ;
33393 PyObject *arg3 = (PyObject *) 0 ;
33394 int arg4 = (int) true ;
33395 PyObject * obj0 = 0 ;
33396 PyObject * obj1 = 0 ;
33397 PyObject * obj2 = 0 ;
33398 PyObject * obj3 = 0 ;
33399 char *kwnames[] = {
33400 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33401 };
33402
33403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33405 if (SWIG_arg_fail(1)) SWIG_fail;
33406 arg2 = obj1;
33407 arg3 = obj2;
33408 if (obj3) {
33409 {
33410 arg4 = static_cast<int >(SWIG_As_int(obj3));
33411 if (SWIG_arg_fail(4)) SWIG_fail;
33412 }
33413 }
33414 {
33415 PyThreadState* __tstate = wxPyBeginAllowThreads();
33416 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33417
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 Py_INCREF(Py_None); resultobj = Py_None;
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33429 PyObject *obj;
33430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33431 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33432 Py_INCREF(obj);
33433 return Py_BuildValue((char *)"");
33434 }
33435 static int _wrap_DefaultValidator_set(PyObject *) {
33436 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33437 return 1;
33438 }
33439
33440
33441 static PyObject *_wrap_DefaultValidator_get(void) {
33442 PyObject *pyobj = NULL;
33443
33444 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33445 return pyobj;
33446 }
33447
33448
33449 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33450 PyObject *resultobj = NULL;
33451 wxString const &arg1_defvalue = wxPyEmptyString ;
33452 wxString *arg1 = (wxString *) &arg1_defvalue ;
33453 long arg2 = (long) 0 ;
33454 wxMenu *result;
33455 bool temp1 = false ;
33456 PyObject * obj0 = 0 ;
33457 PyObject * obj1 = 0 ;
33458 char *kwnames[] = {
33459 (char *) "title",(char *) "style", NULL
33460 };
33461
33462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33463 if (obj0) {
33464 {
33465 arg1 = wxString_in_helper(obj0);
33466 if (arg1 == NULL) SWIG_fail;
33467 temp1 = true;
33468 }
33469 }
33470 if (obj1) {
33471 {
33472 arg2 = static_cast<long >(SWIG_As_long(obj1));
33473 if (SWIG_arg_fail(2)) SWIG_fail;
33474 }
33475 }
33476 {
33477 if (!wxPyCheckForApp()) SWIG_fail;
33478 PyThreadState* __tstate = wxPyBeginAllowThreads();
33479 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33480
33481 wxPyEndAllowThreads(__tstate);
33482 if (PyErr_Occurred()) SWIG_fail;
33483 }
33484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33485 {
33486 if (temp1)
33487 delete arg1;
33488 }
33489 return resultobj;
33490 fail:
33491 {
33492 if (temp1)
33493 delete arg1;
33494 }
33495 return NULL;
33496 }
33497
33498
33499 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33500 PyObject *resultobj = NULL;
33501 wxMenu *arg1 = (wxMenu *) 0 ;
33502 int arg2 ;
33503 wxString *arg3 = 0 ;
33504 wxString const &arg4_defvalue = wxPyEmptyString ;
33505 wxString *arg4 = (wxString *) &arg4_defvalue ;
33506 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33507 wxMenuItem *result;
33508 bool temp3 = false ;
33509 bool temp4 = false ;
33510 PyObject * obj0 = 0 ;
33511 PyObject * obj1 = 0 ;
33512 PyObject * obj2 = 0 ;
33513 PyObject * obj3 = 0 ;
33514 PyObject * obj4 = 0 ;
33515 char *kwnames[] = {
33516 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33517 };
33518
33519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33521 if (SWIG_arg_fail(1)) SWIG_fail;
33522 {
33523 arg2 = static_cast<int >(SWIG_As_int(obj1));
33524 if (SWIG_arg_fail(2)) SWIG_fail;
33525 }
33526 {
33527 arg3 = wxString_in_helper(obj2);
33528 if (arg3 == NULL) SWIG_fail;
33529 temp3 = true;
33530 }
33531 if (obj3) {
33532 {
33533 arg4 = wxString_in_helper(obj3);
33534 if (arg4 == NULL) SWIG_fail;
33535 temp4 = true;
33536 }
33537 }
33538 if (obj4) {
33539 {
33540 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33541 if (SWIG_arg_fail(5)) SWIG_fail;
33542 }
33543 }
33544 {
33545 PyThreadState* __tstate = wxPyBeginAllowThreads();
33546 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33547
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 {
33552 resultobj = wxPyMake_wxObject(result, 0);
33553 }
33554 {
33555 if (temp3)
33556 delete arg3;
33557 }
33558 {
33559 if (temp4)
33560 delete arg4;
33561 }
33562 return resultobj;
33563 fail:
33564 {
33565 if (temp3)
33566 delete arg3;
33567 }
33568 {
33569 if (temp4)
33570 delete arg4;
33571 }
33572 return NULL;
33573 }
33574
33575
33576 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33577 PyObject *resultobj = NULL;
33578 wxMenu *arg1 = (wxMenu *) 0 ;
33579 wxMenuItem *result;
33580 PyObject * obj0 = 0 ;
33581 char *kwnames[] = {
33582 (char *) "self", NULL
33583 };
33584
33585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33587 if (SWIG_arg_fail(1)) SWIG_fail;
33588 {
33589 PyThreadState* __tstate = wxPyBeginAllowThreads();
33590 result = (wxMenuItem *)(arg1)->AppendSeparator();
33591
33592 wxPyEndAllowThreads(__tstate);
33593 if (PyErr_Occurred()) SWIG_fail;
33594 }
33595 {
33596 resultobj = wxPyMake_wxObject(result, 0);
33597 }
33598 return resultobj;
33599 fail:
33600 return NULL;
33601 }
33602
33603
33604 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33605 PyObject *resultobj = NULL;
33606 wxMenu *arg1 = (wxMenu *) 0 ;
33607 int arg2 ;
33608 wxString *arg3 = 0 ;
33609 wxString const &arg4_defvalue = wxPyEmptyString ;
33610 wxString *arg4 = (wxString *) &arg4_defvalue ;
33611 wxMenuItem *result;
33612 bool temp3 = false ;
33613 bool temp4 = false ;
33614 PyObject * obj0 = 0 ;
33615 PyObject * obj1 = 0 ;
33616 PyObject * obj2 = 0 ;
33617 PyObject * obj3 = 0 ;
33618 char *kwnames[] = {
33619 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33620 };
33621
33622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33624 if (SWIG_arg_fail(1)) SWIG_fail;
33625 {
33626 arg2 = static_cast<int >(SWIG_As_int(obj1));
33627 if (SWIG_arg_fail(2)) SWIG_fail;
33628 }
33629 {
33630 arg3 = wxString_in_helper(obj2);
33631 if (arg3 == NULL) SWIG_fail;
33632 temp3 = true;
33633 }
33634 if (obj3) {
33635 {
33636 arg4 = wxString_in_helper(obj3);
33637 if (arg4 == NULL) SWIG_fail;
33638 temp4 = true;
33639 }
33640 }
33641 {
33642 PyThreadState* __tstate = wxPyBeginAllowThreads();
33643 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33644
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 {
33649 resultobj = wxPyMake_wxObject(result, 0);
33650 }
33651 {
33652 if (temp3)
33653 delete arg3;
33654 }
33655 {
33656 if (temp4)
33657 delete arg4;
33658 }
33659 return resultobj;
33660 fail:
33661 {
33662 if (temp3)
33663 delete arg3;
33664 }
33665 {
33666 if (temp4)
33667 delete arg4;
33668 }
33669 return NULL;
33670 }
33671
33672
33673 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj = NULL;
33675 wxMenu *arg1 = (wxMenu *) 0 ;
33676 int arg2 ;
33677 wxString *arg3 = 0 ;
33678 wxString const &arg4_defvalue = wxPyEmptyString ;
33679 wxString *arg4 = (wxString *) &arg4_defvalue ;
33680 wxMenuItem *result;
33681 bool temp3 = false ;
33682 bool temp4 = false ;
33683 PyObject * obj0 = 0 ;
33684 PyObject * obj1 = 0 ;
33685 PyObject * obj2 = 0 ;
33686 PyObject * obj3 = 0 ;
33687 char *kwnames[] = {
33688 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33689 };
33690
33691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33693 if (SWIG_arg_fail(1)) SWIG_fail;
33694 {
33695 arg2 = static_cast<int >(SWIG_As_int(obj1));
33696 if (SWIG_arg_fail(2)) SWIG_fail;
33697 }
33698 {
33699 arg3 = wxString_in_helper(obj2);
33700 if (arg3 == NULL) SWIG_fail;
33701 temp3 = true;
33702 }
33703 if (obj3) {
33704 {
33705 arg4 = wxString_in_helper(obj3);
33706 if (arg4 == NULL) SWIG_fail;
33707 temp4 = true;
33708 }
33709 }
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33713
33714 wxPyEndAllowThreads(__tstate);
33715 if (PyErr_Occurred()) SWIG_fail;
33716 }
33717 {
33718 resultobj = wxPyMake_wxObject(result, 0);
33719 }
33720 {
33721 if (temp3)
33722 delete arg3;
33723 }
33724 {
33725 if (temp4)
33726 delete arg4;
33727 }
33728 return resultobj;
33729 fail:
33730 {
33731 if (temp3)
33732 delete arg3;
33733 }
33734 {
33735 if (temp4)
33736 delete arg4;
33737 }
33738 return NULL;
33739 }
33740
33741
33742 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33743 PyObject *resultobj = NULL;
33744 wxMenu *arg1 = (wxMenu *) 0 ;
33745 int arg2 ;
33746 wxString *arg3 = 0 ;
33747 wxMenu *arg4 = (wxMenu *) 0 ;
33748 wxString const &arg5_defvalue = wxPyEmptyString ;
33749 wxString *arg5 = (wxString *) &arg5_defvalue ;
33750 wxMenuItem *result;
33751 bool temp3 = false ;
33752 bool temp5 = false ;
33753 PyObject * obj0 = 0 ;
33754 PyObject * obj1 = 0 ;
33755 PyObject * obj2 = 0 ;
33756 PyObject * obj3 = 0 ;
33757 PyObject * obj4 = 0 ;
33758 char *kwnames[] = {
33759 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33760 };
33761
33762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33764 if (SWIG_arg_fail(1)) SWIG_fail;
33765 {
33766 arg2 = static_cast<int >(SWIG_As_int(obj1));
33767 if (SWIG_arg_fail(2)) SWIG_fail;
33768 }
33769 {
33770 arg3 = wxString_in_helper(obj2);
33771 if (arg3 == NULL) SWIG_fail;
33772 temp3 = true;
33773 }
33774 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33775 if (SWIG_arg_fail(4)) SWIG_fail;
33776 if (obj4) {
33777 {
33778 arg5 = wxString_in_helper(obj4);
33779 if (arg5 == NULL) SWIG_fail;
33780 temp5 = true;
33781 }
33782 }
33783 {
33784 PyThreadState* __tstate = wxPyBeginAllowThreads();
33785 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33786
33787 wxPyEndAllowThreads(__tstate);
33788 if (PyErr_Occurred()) SWIG_fail;
33789 }
33790 {
33791 resultobj = wxPyMake_wxObject(result, 0);
33792 }
33793 {
33794 if (temp3)
33795 delete arg3;
33796 }
33797 {
33798 if (temp5)
33799 delete arg5;
33800 }
33801 return resultobj;
33802 fail:
33803 {
33804 if (temp3)
33805 delete arg3;
33806 }
33807 {
33808 if (temp5)
33809 delete arg5;
33810 }
33811 return NULL;
33812 }
33813
33814
33815 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj = NULL;
33817 wxMenu *arg1 = (wxMenu *) 0 ;
33818 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33819 wxMenuItem *result;
33820 PyObject * obj0 = 0 ;
33821 PyObject * obj1 = 0 ;
33822 char *kwnames[] = {
33823 (char *) "self",(char *) "item", NULL
33824 };
33825
33826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33828 if (SWIG_arg_fail(1)) SWIG_fail;
33829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33830 if (SWIG_arg_fail(2)) SWIG_fail;
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 result = (wxMenuItem *)(arg1)->Append(arg2);
33834
33835 wxPyEndAllowThreads(__tstate);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 }
33838 {
33839 resultobj = wxPyMake_wxObject(result, 0);
33840 }
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj = NULL;
33849 wxMenu *arg1 = (wxMenu *) 0 ;
33850 PyObject * obj0 = 0 ;
33851 char *kwnames[] = {
33852 (char *) "self", NULL
33853 };
33854
33855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33857 if (SWIG_arg_fail(1)) SWIG_fail;
33858 {
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 (arg1)->Break();
33861
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 Py_INCREF(Py_None); resultobj = Py_None;
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = NULL;
33874 wxMenu *arg1 = (wxMenu *) 0 ;
33875 size_t arg2 ;
33876 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33877 wxMenuItem *result;
33878 PyObject * obj0 = 0 ;
33879 PyObject * obj1 = 0 ;
33880 PyObject * obj2 = 0 ;
33881 char *kwnames[] = {
33882 (char *) "self",(char *) "pos",(char *) "item", NULL
33883 };
33884
33885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33887 if (SWIG_arg_fail(1)) SWIG_fail;
33888 {
33889 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33890 if (SWIG_arg_fail(2)) SWIG_fail;
33891 }
33892 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33893 if (SWIG_arg_fail(3)) SWIG_fail;
33894 {
33895 PyThreadState* __tstate = wxPyBeginAllowThreads();
33896 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33897
33898 wxPyEndAllowThreads(__tstate);
33899 if (PyErr_Occurred()) SWIG_fail;
33900 }
33901 {
33902 resultobj = wxPyMake_wxObject(result, 0);
33903 }
33904 return resultobj;
33905 fail:
33906 return NULL;
33907 }
33908
33909
33910 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33911 PyObject *resultobj = NULL;
33912 wxMenu *arg1 = (wxMenu *) 0 ;
33913 size_t arg2 ;
33914 int arg3 ;
33915 wxString *arg4 = 0 ;
33916 wxString const &arg5_defvalue = wxPyEmptyString ;
33917 wxString *arg5 = (wxString *) &arg5_defvalue ;
33918 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33919 wxMenuItem *result;
33920 bool temp4 = false ;
33921 bool temp5 = false ;
33922 PyObject * obj0 = 0 ;
33923 PyObject * obj1 = 0 ;
33924 PyObject * obj2 = 0 ;
33925 PyObject * obj3 = 0 ;
33926 PyObject * obj4 = 0 ;
33927 PyObject * obj5 = 0 ;
33928 char *kwnames[] = {
33929 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33930 };
33931
33932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33934 if (SWIG_arg_fail(1)) SWIG_fail;
33935 {
33936 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33937 if (SWIG_arg_fail(2)) SWIG_fail;
33938 }
33939 {
33940 arg3 = static_cast<int >(SWIG_As_int(obj2));
33941 if (SWIG_arg_fail(3)) SWIG_fail;
33942 }
33943 {
33944 arg4 = wxString_in_helper(obj3);
33945 if (arg4 == NULL) SWIG_fail;
33946 temp4 = true;
33947 }
33948 if (obj4) {
33949 {
33950 arg5 = wxString_in_helper(obj4);
33951 if (arg5 == NULL) SWIG_fail;
33952 temp5 = true;
33953 }
33954 }
33955 if (obj5) {
33956 {
33957 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
33958 if (SWIG_arg_fail(6)) SWIG_fail;
33959 }
33960 }
33961 {
33962 PyThreadState* __tstate = wxPyBeginAllowThreads();
33963 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
33964
33965 wxPyEndAllowThreads(__tstate);
33966 if (PyErr_Occurred()) SWIG_fail;
33967 }
33968 {
33969 resultobj = wxPyMake_wxObject(result, 0);
33970 }
33971 {
33972 if (temp4)
33973 delete arg4;
33974 }
33975 {
33976 if (temp5)
33977 delete arg5;
33978 }
33979 return resultobj;
33980 fail:
33981 {
33982 if (temp4)
33983 delete arg4;
33984 }
33985 {
33986 if (temp5)
33987 delete arg5;
33988 }
33989 return NULL;
33990 }
33991
33992
33993 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33994 PyObject *resultobj = NULL;
33995 wxMenu *arg1 = (wxMenu *) 0 ;
33996 size_t arg2 ;
33997 wxMenuItem *result;
33998 PyObject * obj0 = 0 ;
33999 PyObject * obj1 = 0 ;
34000 char *kwnames[] = {
34001 (char *) "self",(char *) "pos", NULL
34002 };
34003
34004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
34005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34006 if (SWIG_arg_fail(1)) SWIG_fail;
34007 {
34008 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34009 if (SWIG_arg_fail(2)) SWIG_fail;
34010 }
34011 {
34012 PyThreadState* __tstate = wxPyBeginAllowThreads();
34013 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34014
34015 wxPyEndAllowThreads(__tstate);
34016 if (PyErr_Occurred()) SWIG_fail;
34017 }
34018 {
34019 resultobj = wxPyMake_wxObject(result, 0);
34020 }
34021 return resultobj;
34022 fail:
34023 return NULL;
34024 }
34025
34026
34027 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34028 PyObject *resultobj = NULL;
34029 wxMenu *arg1 = (wxMenu *) 0 ;
34030 size_t arg2 ;
34031 int arg3 ;
34032 wxString *arg4 = 0 ;
34033 wxString const &arg5_defvalue = wxPyEmptyString ;
34034 wxString *arg5 = (wxString *) &arg5_defvalue ;
34035 wxMenuItem *result;
34036 bool temp4 = false ;
34037 bool temp5 = false ;
34038 PyObject * obj0 = 0 ;
34039 PyObject * obj1 = 0 ;
34040 PyObject * obj2 = 0 ;
34041 PyObject * obj3 = 0 ;
34042 PyObject * obj4 = 0 ;
34043 char *kwnames[] = {
34044 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34045 };
34046
34047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34049 if (SWIG_arg_fail(1)) SWIG_fail;
34050 {
34051 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34052 if (SWIG_arg_fail(2)) SWIG_fail;
34053 }
34054 {
34055 arg3 = static_cast<int >(SWIG_As_int(obj2));
34056 if (SWIG_arg_fail(3)) SWIG_fail;
34057 }
34058 {
34059 arg4 = wxString_in_helper(obj3);
34060 if (arg4 == NULL) SWIG_fail;
34061 temp4 = true;
34062 }
34063 if (obj4) {
34064 {
34065 arg5 = wxString_in_helper(obj4);
34066 if (arg5 == NULL) SWIG_fail;
34067 temp5 = true;
34068 }
34069 }
34070 {
34071 PyThreadState* __tstate = wxPyBeginAllowThreads();
34072 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34073
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 {
34078 resultobj = wxPyMake_wxObject(result, 0);
34079 }
34080 {
34081 if (temp4)
34082 delete arg4;
34083 }
34084 {
34085 if (temp5)
34086 delete arg5;
34087 }
34088 return resultobj;
34089 fail:
34090 {
34091 if (temp4)
34092 delete arg4;
34093 }
34094 {
34095 if (temp5)
34096 delete arg5;
34097 }
34098 return NULL;
34099 }
34100
34101
34102 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj = NULL;
34104 wxMenu *arg1 = (wxMenu *) 0 ;
34105 size_t arg2 ;
34106 int arg3 ;
34107 wxString *arg4 = 0 ;
34108 wxString const &arg5_defvalue = wxPyEmptyString ;
34109 wxString *arg5 = (wxString *) &arg5_defvalue ;
34110 wxMenuItem *result;
34111 bool temp4 = false ;
34112 bool temp5 = false ;
34113 PyObject * obj0 = 0 ;
34114 PyObject * obj1 = 0 ;
34115 PyObject * obj2 = 0 ;
34116 PyObject * obj3 = 0 ;
34117 PyObject * obj4 = 0 ;
34118 char *kwnames[] = {
34119 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34120 };
34121
34122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34124 if (SWIG_arg_fail(1)) SWIG_fail;
34125 {
34126 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34127 if (SWIG_arg_fail(2)) SWIG_fail;
34128 }
34129 {
34130 arg3 = static_cast<int >(SWIG_As_int(obj2));
34131 if (SWIG_arg_fail(3)) SWIG_fail;
34132 }
34133 {
34134 arg4 = wxString_in_helper(obj3);
34135 if (arg4 == NULL) SWIG_fail;
34136 temp4 = true;
34137 }
34138 if (obj4) {
34139 {
34140 arg5 = wxString_in_helper(obj4);
34141 if (arg5 == NULL) SWIG_fail;
34142 temp5 = true;
34143 }
34144 }
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34148
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 {
34153 resultobj = wxPyMake_wxObject(result, 0);
34154 }
34155 {
34156 if (temp4)
34157 delete arg4;
34158 }
34159 {
34160 if (temp5)
34161 delete arg5;
34162 }
34163 return resultobj;
34164 fail:
34165 {
34166 if (temp4)
34167 delete arg4;
34168 }
34169 {
34170 if (temp5)
34171 delete arg5;
34172 }
34173 return NULL;
34174 }
34175
34176
34177 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34178 PyObject *resultobj = NULL;
34179 wxMenu *arg1 = (wxMenu *) 0 ;
34180 size_t arg2 ;
34181 int arg3 ;
34182 wxString *arg4 = 0 ;
34183 wxMenu *arg5 = (wxMenu *) 0 ;
34184 wxString const &arg6_defvalue = wxPyEmptyString ;
34185 wxString *arg6 = (wxString *) &arg6_defvalue ;
34186 wxMenuItem *result;
34187 bool temp4 = false ;
34188 bool temp6 = false ;
34189 PyObject * obj0 = 0 ;
34190 PyObject * obj1 = 0 ;
34191 PyObject * obj2 = 0 ;
34192 PyObject * obj3 = 0 ;
34193 PyObject * obj4 = 0 ;
34194 PyObject * obj5 = 0 ;
34195 char *kwnames[] = {
34196 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34197 };
34198
34199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34201 if (SWIG_arg_fail(1)) SWIG_fail;
34202 {
34203 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34204 if (SWIG_arg_fail(2)) SWIG_fail;
34205 }
34206 {
34207 arg3 = static_cast<int >(SWIG_As_int(obj2));
34208 if (SWIG_arg_fail(3)) SWIG_fail;
34209 }
34210 {
34211 arg4 = wxString_in_helper(obj3);
34212 if (arg4 == NULL) SWIG_fail;
34213 temp4 = true;
34214 }
34215 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34216 if (SWIG_arg_fail(5)) SWIG_fail;
34217 if (obj5) {
34218 {
34219 arg6 = wxString_in_helper(obj5);
34220 if (arg6 == NULL) SWIG_fail;
34221 temp6 = true;
34222 }
34223 }
34224 {
34225 PyThreadState* __tstate = wxPyBeginAllowThreads();
34226 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34227
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 {
34232 resultobj = wxPyMake_wxObject(result, 0);
34233 }
34234 {
34235 if (temp4)
34236 delete arg4;
34237 }
34238 {
34239 if (temp6)
34240 delete arg6;
34241 }
34242 return resultobj;
34243 fail:
34244 {
34245 if (temp4)
34246 delete arg4;
34247 }
34248 {
34249 if (temp6)
34250 delete arg6;
34251 }
34252 return NULL;
34253 }
34254
34255
34256 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34257 PyObject *resultobj = NULL;
34258 wxMenu *arg1 = (wxMenu *) 0 ;
34259 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34260 wxMenuItem *result;
34261 PyObject * obj0 = 0 ;
34262 PyObject * obj1 = 0 ;
34263 char *kwnames[] = {
34264 (char *) "self",(char *) "item", NULL
34265 };
34266
34267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34269 if (SWIG_arg_fail(1)) SWIG_fail;
34270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34271 if (SWIG_arg_fail(2)) SWIG_fail;
34272 {
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34275
34276 wxPyEndAllowThreads(__tstate);
34277 if (PyErr_Occurred()) SWIG_fail;
34278 }
34279 {
34280 resultobj = wxPyMake_wxObject(result, 0);
34281 }
34282 return resultobj;
34283 fail:
34284 return NULL;
34285 }
34286
34287
34288 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34289 PyObject *resultobj = NULL;
34290 wxMenu *arg1 = (wxMenu *) 0 ;
34291 int arg2 ;
34292 wxString *arg3 = 0 ;
34293 wxString const &arg4_defvalue = wxPyEmptyString ;
34294 wxString *arg4 = (wxString *) &arg4_defvalue ;
34295 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34296 wxMenuItem *result;
34297 bool temp3 = false ;
34298 bool temp4 = false ;
34299 PyObject * obj0 = 0 ;
34300 PyObject * obj1 = 0 ;
34301 PyObject * obj2 = 0 ;
34302 PyObject * obj3 = 0 ;
34303 PyObject * obj4 = 0 ;
34304 char *kwnames[] = {
34305 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34306 };
34307
34308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34310 if (SWIG_arg_fail(1)) SWIG_fail;
34311 {
34312 arg2 = static_cast<int >(SWIG_As_int(obj1));
34313 if (SWIG_arg_fail(2)) SWIG_fail;
34314 }
34315 {
34316 arg3 = wxString_in_helper(obj2);
34317 if (arg3 == NULL) SWIG_fail;
34318 temp3 = true;
34319 }
34320 if (obj3) {
34321 {
34322 arg4 = wxString_in_helper(obj3);
34323 if (arg4 == NULL) SWIG_fail;
34324 temp4 = true;
34325 }
34326 }
34327 if (obj4) {
34328 {
34329 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34330 if (SWIG_arg_fail(5)) SWIG_fail;
34331 }
34332 }
34333 {
34334 PyThreadState* __tstate = wxPyBeginAllowThreads();
34335 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34336
34337 wxPyEndAllowThreads(__tstate);
34338 if (PyErr_Occurred()) SWIG_fail;
34339 }
34340 {
34341 resultobj = wxPyMake_wxObject(result, 0);
34342 }
34343 {
34344 if (temp3)
34345 delete arg3;
34346 }
34347 {
34348 if (temp4)
34349 delete arg4;
34350 }
34351 return resultobj;
34352 fail:
34353 {
34354 if (temp3)
34355 delete arg3;
34356 }
34357 {
34358 if (temp4)
34359 delete arg4;
34360 }
34361 return NULL;
34362 }
34363
34364
34365 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34366 PyObject *resultobj = NULL;
34367 wxMenu *arg1 = (wxMenu *) 0 ;
34368 wxMenuItem *result;
34369 PyObject * obj0 = 0 ;
34370 char *kwnames[] = {
34371 (char *) "self", NULL
34372 };
34373
34374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34376 if (SWIG_arg_fail(1)) SWIG_fail;
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 result = (wxMenuItem *)(arg1)->PrependSeparator();
34380
34381 wxPyEndAllowThreads(__tstate);
34382 if (PyErr_Occurred()) SWIG_fail;
34383 }
34384 {
34385 resultobj = wxPyMake_wxObject(result, 0);
34386 }
34387 return resultobj;
34388 fail:
34389 return NULL;
34390 }
34391
34392
34393 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34394 PyObject *resultobj = NULL;
34395 wxMenu *arg1 = (wxMenu *) 0 ;
34396 int arg2 ;
34397 wxString *arg3 = 0 ;
34398 wxString const &arg4_defvalue = wxPyEmptyString ;
34399 wxString *arg4 = (wxString *) &arg4_defvalue ;
34400 wxMenuItem *result;
34401 bool temp3 = false ;
34402 bool temp4 = false ;
34403 PyObject * obj0 = 0 ;
34404 PyObject * obj1 = 0 ;
34405 PyObject * obj2 = 0 ;
34406 PyObject * obj3 = 0 ;
34407 char *kwnames[] = {
34408 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34409 };
34410
34411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34413 if (SWIG_arg_fail(1)) SWIG_fail;
34414 {
34415 arg2 = static_cast<int >(SWIG_As_int(obj1));
34416 if (SWIG_arg_fail(2)) SWIG_fail;
34417 }
34418 {
34419 arg3 = wxString_in_helper(obj2);
34420 if (arg3 == NULL) SWIG_fail;
34421 temp3 = true;
34422 }
34423 if (obj3) {
34424 {
34425 arg4 = wxString_in_helper(obj3);
34426 if (arg4 == NULL) SWIG_fail;
34427 temp4 = true;
34428 }
34429 }
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34433
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 resultobj = wxPyMake_wxObject(result, 0);
34439 }
34440 {
34441 if (temp3)
34442 delete arg3;
34443 }
34444 {
34445 if (temp4)
34446 delete arg4;
34447 }
34448 return resultobj;
34449 fail:
34450 {
34451 if (temp3)
34452 delete arg3;
34453 }
34454 {
34455 if (temp4)
34456 delete arg4;
34457 }
34458 return NULL;
34459 }
34460
34461
34462 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34463 PyObject *resultobj = NULL;
34464 wxMenu *arg1 = (wxMenu *) 0 ;
34465 int arg2 ;
34466 wxString *arg3 = 0 ;
34467 wxString const &arg4_defvalue = wxPyEmptyString ;
34468 wxString *arg4 = (wxString *) &arg4_defvalue ;
34469 wxMenuItem *result;
34470 bool temp3 = false ;
34471 bool temp4 = false ;
34472 PyObject * obj0 = 0 ;
34473 PyObject * obj1 = 0 ;
34474 PyObject * obj2 = 0 ;
34475 PyObject * obj3 = 0 ;
34476 char *kwnames[] = {
34477 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34478 };
34479
34480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34482 if (SWIG_arg_fail(1)) SWIG_fail;
34483 {
34484 arg2 = static_cast<int >(SWIG_As_int(obj1));
34485 if (SWIG_arg_fail(2)) SWIG_fail;
34486 }
34487 {
34488 arg3 = wxString_in_helper(obj2);
34489 if (arg3 == NULL) SWIG_fail;
34490 temp3 = true;
34491 }
34492 if (obj3) {
34493 {
34494 arg4 = wxString_in_helper(obj3);
34495 if (arg4 == NULL) SWIG_fail;
34496 temp4 = true;
34497 }
34498 }
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34502
34503 wxPyEndAllowThreads(__tstate);
34504 if (PyErr_Occurred()) SWIG_fail;
34505 }
34506 {
34507 resultobj = wxPyMake_wxObject(result, 0);
34508 }
34509 {
34510 if (temp3)
34511 delete arg3;
34512 }
34513 {
34514 if (temp4)
34515 delete arg4;
34516 }
34517 return resultobj;
34518 fail:
34519 {
34520 if (temp3)
34521 delete arg3;
34522 }
34523 {
34524 if (temp4)
34525 delete arg4;
34526 }
34527 return NULL;
34528 }
34529
34530
34531 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34532 PyObject *resultobj = NULL;
34533 wxMenu *arg1 = (wxMenu *) 0 ;
34534 int arg2 ;
34535 wxString *arg3 = 0 ;
34536 wxMenu *arg4 = (wxMenu *) 0 ;
34537 wxString const &arg5_defvalue = wxPyEmptyString ;
34538 wxString *arg5 = (wxString *) &arg5_defvalue ;
34539 wxMenuItem *result;
34540 bool temp3 = false ;
34541 bool temp5 = false ;
34542 PyObject * obj0 = 0 ;
34543 PyObject * obj1 = 0 ;
34544 PyObject * obj2 = 0 ;
34545 PyObject * obj3 = 0 ;
34546 PyObject * obj4 = 0 ;
34547 char *kwnames[] = {
34548 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34549 };
34550
34551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34553 if (SWIG_arg_fail(1)) SWIG_fail;
34554 {
34555 arg2 = static_cast<int >(SWIG_As_int(obj1));
34556 if (SWIG_arg_fail(2)) SWIG_fail;
34557 }
34558 {
34559 arg3 = wxString_in_helper(obj2);
34560 if (arg3 == NULL) SWIG_fail;
34561 temp3 = true;
34562 }
34563 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34564 if (SWIG_arg_fail(4)) SWIG_fail;
34565 if (obj4) {
34566 {
34567 arg5 = wxString_in_helper(obj4);
34568 if (arg5 == NULL) SWIG_fail;
34569 temp5 = true;
34570 }
34571 }
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34575
34576 wxPyEndAllowThreads(__tstate);
34577 if (PyErr_Occurred()) SWIG_fail;
34578 }
34579 {
34580 resultobj = wxPyMake_wxObject(result, 0);
34581 }
34582 {
34583 if (temp3)
34584 delete arg3;
34585 }
34586 {
34587 if (temp5)
34588 delete arg5;
34589 }
34590 return resultobj;
34591 fail:
34592 {
34593 if (temp3)
34594 delete arg3;
34595 }
34596 {
34597 if (temp5)
34598 delete arg5;
34599 }
34600 return NULL;
34601 }
34602
34603
34604 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34605 PyObject *resultobj = NULL;
34606 wxMenu *arg1 = (wxMenu *) 0 ;
34607 int arg2 ;
34608 wxMenuItem *result;
34609 PyObject * obj0 = 0 ;
34610 PyObject * obj1 = 0 ;
34611 char *kwnames[] = {
34612 (char *) "self",(char *) "id", NULL
34613 };
34614
34615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34617 if (SWIG_arg_fail(1)) SWIG_fail;
34618 {
34619 arg2 = static_cast<int >(SWIG_As_int(obj1));
34620 if (SWIG_arg_fail(2)) SWIG_fail;
34621 }
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (wxMenuItem *)(arg1)->Remove(arg2);
34625
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 {
34630 resultobj = wxPyMake_wxObject(result, 0);
34631 }
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj = NULL;
34640 wxMenu *arg1 = (wxMenu *) 0 ;
34641 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34642 wxMenuItem *result;
34643 PyObject * obj0 = 0 ;
34644 PyObject * obj1 = 0 ;
34645 char *kwnames[] = {
34646 (char *) "self",(char *) "item", NULL
34647 };
34648
34649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34651 if (SWIG_arg_fail(1)) SWIG_fail;
34652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34653 if (SWIG_arg_fail(2)) SWIG_fail;
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 result = (wxMenuItem *)(arg1)->Remove(arg2);
34657
34658 wxPyEndAllowThreads(__tstate);
34659 if (PyErr_Occurred()) SWIG_fail;
34660 }
34661 {
34662 resultobj = wxPyMake_wxObject(result, 0);
34663 }
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34671 PyObject *resultobj = NULL;
34672 wxMenu *arg1 = (wxMenu *) 0 ;
34673 int arg2 ;
34674 bool result;
34675 PyObject * obj0 = 0 ;
34676 PyObject * obj1 = 0 ;
34677 char *kwnames[] = {
34678 (char *) "self",(char *) "id", NULL
34679 };
34680
34681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34683 if (SWIG_arg_fail(1)) SWIG_fail;
34684 {
34685 arg2 = static_cast<int >(SWIG_As_int(obj1));
34686 if (SWIG_arg_fail(2)) SWIG_fail;
34687 }
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 result = (bool)(arg1)->Delete(arg2);
34691
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 {
34696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34697 }
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj = NULL;
34706 wxMenu *arg1 = (wxMenu *) 0 ;
34707 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34708 bool result;
34709 PyObject * obj0 = 0 ;
34710 PyObject * obj1 = 0 ;
34711 char *kwnames[] = {
34712 (char *) "self",(char *) "item", NULL
34713 };
34714
34715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34717 if (SWIG_arg_fail(1)) SWIG_fail;
34718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34719 if (SWIG_arg_fail(2)) SWIG_fail;
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = (bool)(arg1)->Delete(arg2);
34723
34724 wxPyEndAllowThreads(__tstate);
34725 if (PyErr_Occurred()) SWIG_fail;
34726 }
34727 {
34728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34729 }
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34737 PyObject *resultobj = NULL;
34738 wxMenu *arg1 = (wxMenu *) 0 ;
34739 PyObject * obj0 = 0 ;
34740 char *kwnames[] = {
34741 (char *) "self", NULL
34742 };
34743
34744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34746 if (SWIG_arg_fail(1)) SWIG_fail;
34747 {
34748 PyThreadState* __tstate = wxPyBeginAllowThreads();
34749 wxMenu_Destroy(arg1);
34750
34751 wxPyEndAllowThreads(__tstate);
34752 if (PyErr_Occurred()) SWIG_fail;
34753 }
34754 Py_INCREF(Py_None); resultobj = Py_None;
34755 return resultobj;
34756 fail:
34757 return NULL;
34758 }
34759
34760
34761 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34762 PyObject *resultobj = NULL;
34763 wxMenu *arg1 = (wxMenu *) 0 ;
34764 int arg2 ;
34765 bool result;
34766 PyObject * obj0 = 0 ;
34767 PyObject * obj1 = 0 ;
34768 char *kwnames[] = {
34769 (char *) "self",(char *) "id", NULL
34770 };
34771
34772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34774 if (SWIG_arg_fail(1)) SWIG_fail;
34775 {
34776 arg2 = static_cast<int >(SWIG_As_int(obj1));
34777 if (SWIG_arg_fail(2)) SWIG_fail;
34778 }
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 result = (bool)(arg1)->Destroy(arg2);
34782
34783 wxPyEndAllowThreads(__tstate);
34784 if (PyErr_Occurred()) SWIG_fail;
34785 }
34786 {
34787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34788 }
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34796 PyObject *resultobj = NULL;
34797 wxMenu *arg1 = (wxMenu *) 0 ;
34798 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34799 bool result;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 char *kwnames[] = {
34803 (char *) "self",(char *) "item", NULL
34804 };
34805
34806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34808 if (SWIG_arg_fail(1)) SWIG_fail;
34809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34810 if (SWIG_arg_fail(2)) SWIG_fail;
34811 {
34812 PyThreadState* __tstate = wxPyBeginAllowThreads();
34813 result = (bool)(arg1)->Destroy(arg2);
34814
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 {
34819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34820 }
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34828 PyObject *resultobj = NULL;
34829 wxMenu *arg1 = (wxMenu *) 0 ;
34830 size_t result;
34831 PyObject * obj0 = 0 ;
34832 char *kwnames[] = {
34833 (char *) "self", NULL
34834 };
34835
34836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34838 if (SWIG_arg_fail(1)) SWIG_fail;
34839 {
34840 PyThreadState* __tstate = wxPyBeginAllowThreads();
34841 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34842
34843 wxPyEndAllowThreads(__tstate);
34844 if (PyErr_Occurred()) SWIG_fail;
34845 }
34846 {
34847 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34848 }
34849 return resultobj;
34850 fail:
34851 return NULL;
34852 }
34853
34854
34855 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34856 PyObject *resultobj = NULL;
34857 wxMenu *arg1 = (wxMenu *) 0 ;
34858 PyObject *result;
34859 PyObject * obj0 = 0 ;
34860 char *kwnames[] = {
34861 (char *) "self", NULL
34862 };
34863
34864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34866 if (SWIG_arg_fail(1)) SWIG_fail;
34867 {
34868 PyThreadState* __tstate = wxPyBeginAllowThreads();
34869 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34870
34871 wxPyEndAllowThreads(__tstate);
34872 if (PyErr_Occurred()) SWIG_fail;
34873 }
34874 resultobj = result;
34875 return resultobj;
34876 fail:
34877 return NULL;
34878 }
34879
34880
34881 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34882 PyObject *resultobj = NULL;
34883 wxMenu *arg1 = (wxMenu *) 0 ;
34884 wxString *arg2 = 0 ;
34885 int result;
34886 bool temp2 = false ;
34887 PyObject * obj0 = 0 ;
34888 PyObject * obj1 = 0 ;
34889 char *kwnames[] = {
34890 (char *) "self",(char *) "item", NULL
34891 };
34892
34893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34895 if (SWIG_arg_fail(1)) SWIG_fail;
34896 {
34897 arg2 = wxString_in_helper(obj1);
34898 if (arg2 == NULL) SWIG_fail;
34899 temp2 = true;
34900 }
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34904
34905 wxPyEndAllowThreads(__tstate);
34906 if (PyErr_Occurred()) SWIG_fail;
34907 }
34908 {
34909 resultobj = SWIG_From_int(static_cast<int >(result));
34910 }
34911 {
34912 if (temp2)
34913 delete arg2;
34914 }
34915 return resultobj;
34916 fail:
34917 {
34918 if (temp2)
34919 delete arg2;
34920 }
34921 return NULL;
34922 }
34923
34924
34925 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34926 PyObject *resultobj = NULL;
34927 wxMenu *arg1 = (wxMenu *) 0 ;
34928 int arg2 ;
34929 wxMenuItem *result;
34930 PyObject * obj0 = 0 ;
34931 PyObject * obj1 = 0 ;
34932 char *kwnames[] = {
34933 (char *) "self",(char *) "id", NULL
34934 };
34935
34936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34938 if (SWIG_arg_fail(1)) SWIG_fail;
34939 {
34940 arg2 = static_cast<int >(SWIG_As_int(obj1));
34941 if (SWIG_arg_fail(2)) SWIG_fail;
34942 }
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34946
34947 wxPyEndAllowThreads(__tstate);
34948 if (PyErr_Occurred()) SWIG_fail;
34949 }
34950 {
34951 resultobj = wxPyMake_wxObject(result, 0);
34952 }
34953 return resultobj;
34954 fail:
34955 return NULL;
34956 }
34957
34958
34959 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34960 PyObject *resultobj = NULL;
34961 wxMenu *arg1 = (wxMenu *) 0 ;
34962 size_t arg2 ;
34963 wxMenuItem *result;
34964 PyObject * obj0 = 0 ;
34965 PyObject * obj1 = 0 ;
34966 char *kwnames[] = {
34967 (char *) "self",(char *) "position", NULL
34968 };
34969
34970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34972 if (SWIG_arg_fail(1)) SWIG_fail;
34973 {
34974 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34975 if (SWIG_arg_fail(2)) SWIG_fail;
34976 }
34977 {
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34980
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 {
34985 resultobj = wxPyMake_wxObject(result, 0);
34986 }
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj = NULL;
34995 wxMenu *arg1 = (wxMenu *) 0 ;
34996 int arg2 ;
34997 bool arg3 ;
34998 PyObject * obj0 = 0 ;
34999 PyObject * obj1 = 0 ;
35000 PyObject * obj2 = 0 ;
35001 char *kwnames[] = {
35002 (char *) "self",(char *) "id",(char *) "enable", NULL
35003 };
35004
35005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35007 if (SWIG_arg_fail(1)) SWIG_fail;
35008 {
35009 arg2 = static_cast<int >(SWIG_As_int(obj1));
35010 if (SWIG_arg_fail(2)) SWIG_fail;
35011 }
35012 {
35013 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35014 if (SWIG_arg_fail(3)) SWIG_fail;
35015 }
35016 {
35017 PyThreadState* __tstate = wxPyBeginAllowThreads();
35018 (arg1)->Enable(arg2,arg3);
35019
35020 wxPyEndAllowThreads(__tstate);
35021 if (PyErr_Occurred()) SWIG_fail;
35022 }
35023 Py_INCREF(Py_None); resultobj = Py_None;
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35031 PyObject *resultobj = NULL;
35032 wxMenu *arg1 = (wxMenu *) 0 ;
35033 int arg2 ;
35034 bool result;
35035 PyObject * obj0 = 0 ;
35036 PyObject * obj1 = 0 ;
35037 char *kwnames[] = {
35038 (char *) "self",(char *) "id", NULL
35039 };
35040
35041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35043 if (SWIG_arg_fail(1)) SWIG_fail;
35044 {
35045 arg2 = static_cast<int >(SWIG_As_int(obj1));
35046 if (SWIG_arg_fail(2)) SWIG_fail;
35047 }
35048 {
35049 PyThreadState* __tstate = wxPyBeginAllowThreads();
35050 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35051
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 {
35056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35057 }
35058 return resultobj;
35059 fail:
35060 return NULL;
35061 }
35062
35063
35064 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35065 PyObject *resultobj = NULL;
35066 wxMenu *arg1 = (wxMenu *) 0 ;
35067 int arg2 ;
35068 bool arg3 ;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 PyObject * obj2 = 0 ;
35072 char *kwnames[] = {
35073 (char *) "self",(char *) "id",(char *) "check", NULL
35074 };
35075
35076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35078 if (SWIG_arg_fail(1)) SWIG_fail;
35079 {
35080 arg2 = static_cast<int >(SWIG_As_int(obj1));
35081 if (SWIG_arg_fail(2)) SWIG_fail;
35082 }
35083 {
35084 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35085 if (SWIG_arg_fail(3)) SWIG_fail;
35086 }
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 (arg1)->Check(arg2,arg3);
35090
35091 wxPyEndAllowThreads(__tstate);
35092 if (PyErr_Occurred()) SWIG_fail;
35093 }
35094 Py_INCREF(Py_None); resultobj = Py_None;
35095 return resultobj;
35096 fail:
35097 return NULL;
35098 }
35099
35100
35101 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35102 PyObject *resultobj = NULL;
35103 wxMenu *arg1 = (wxMenu *) 0 ;
35104 int arg2 ;
35105 bool result;
35106 PyObject * obj0 = 0 ;
35107 PyObject * obj1 = 0 ;
35108 char *kwnames[] = {
35109 (char *) "self",(char *) "id", NULL
35110 };
35111
35112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35114 if (SWIG_arg_fail(1)) SWIG_fail;
35115 {
35116 arg2 = static_cast<int >(SWIG_As_int(obj1));
35117 if (SWIG_arg_fail(2)) SWIG_fail;
35118 }
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35122
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 {
35127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35128 }
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35136 PyObject *resultobj = NULL;
35137 wxMenu *arg1 = (wxMenu *) 0 ;
35138 int arg2 ;
35139 wxString *arg3 = 0 ;
35140 bool temp3 = false ;
35141 PyObject * obj0 = 0 ;
35142 PyObject * obj1 = 0 ;
35143 PyObject * obj2 = 0 ;
35144 char *kwnames[] = {
35145 (char *) "self",(char *) "id",(char *) "label", NULL
35146 };
35147
35148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35150 if (SWIG_arg_fail(1)) SWIG_fail;
35151 {
35152 arg2 = static_cast<int >(SWIG_As_int(obj1));
35153 if (SWIG_arg_fail(2)) SWIG_fail;
35154 }
35155 {
35156 arg3 = wxString_in_helper(obj2);
35157 if (arg3 == NULL) SWIG_fail;
35158 temp3 = true;
35159 }
35160 {
35161 PyThreadState* __tstate = wxPyBeginAllowThreads();
35162 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35163
35164 wxPyEndAllowThreads(__tstate);
35165 if (PyErr_Occurred()) SWIG_fail;
35166 }
35167 Py_INCREF(Py_None); resultobj = Py_None;
35168 {
35169 if (temp3)
35170 delete arg3;
35171 }
35172 return resultobj;
35173 fail:
35174 {
35175 if (temp3)
35176 delete arg3;
35177 }
35178 return NULL;
35179 }
35180
35181
35182 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35183 PyObject *resultobj = NULL;
35184 wxMenu *arg1 = (wxMenu *) 0 ;
35185 int arg2 ;
35186 wxString result;
35187 PyObject * obj0 = 0 ;
35188 PyObject * obj1 = 0 ;
35189 char *kwnames[] = {
35190 (char *) "self",(char *) "id", NULL
35191 };
35192
35193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35195 if (SWIG_arg_fail(1)) SWIG_fail;
35196 {
35197 arg2 = static_cast<int >(SWIG_As_int(obj1));
35198 if (SWIG_arg_fail(2)) SWIG_fail;
35199 }
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35203
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 {
35208 #if wxUSE_UNICODE
35209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35210 #else
35211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35212 #endif
35213 }
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj = NULL;
35222 wxMenu *arg1 = (wxMenu *) 0 ;
35223 int arg2 ;
35224 wxString *arg3 = 0 ;
35225 bool temp3 = false ;
35226 PyObject * obj0 = 0 ;
35227 PyObject * obj1 = 0 ;
35228 PyObject * obj2 = 0 ;
35229 char *kwnames[] = {
35230 (char *) "self",(char *) "id",(char *) "helpString", NULL
35231 };
35232
35233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35235 if (SWIG_arg_fail(1)) SWIG_fail;
35236 {
35237 arg2 = static_cast<int >(SWIG_As_int(obj1));
35238 if (SWIG_arg_fail(2)) SWIG_fail;
35239 }
35240 {
35241 arg3 = wxString_in_helper(obj2);
35242 if (arg3 == NULL) SWIG_fail;
35243 temp3 = true;
35244 }
35245 {
35246 PyThreadState* __tstate = wxPyBeginAllowThreads();
35247 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35248
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 Py_INCREF(Py_None); resultobj = Py_None;
35253 {
35254 if (temp3)
35255 delete arg3;
35256 }
35257 return resultobj;
35258 fail:
35259 {
35260 if (temp3)
35261 delete arg3;
35262 }
35263 return NULL;
35264 }
35265
35266
35267 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35268 PyObject *resultobj = NULL;
35269 wxMenu *arg1 = (wxMenu *) 0 ;
35270 int arg2 ;
35271 wxString result;
35272 PyObject * obj0 = 0 ;
35273 PyObject * obj1 = 0 ;
35274 char *kwnames[] = {
35275 (char *) "self",(char *) "id", NULL
35276 };
35277
35278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35280 if (SWIG_arg_fail(1)) SWIG_fail;
35281 {
35282 arg2 = static_cast<int >(SWIG_As_int(obj1));
35283 if (SWIG_arg_fail(2)) SWIG_fail;
35284 }
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35288
35289 wxPyEndAllowThreads(__tstate);
35290 if (PyErr_Occurred()) SWIG_fail;
35291 }
35292 {
35293 #if wxUSE_UNICODE
35294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35295 #else
35296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35297 #endif
35298 }
35299 return resultobj;
35300 fail:
35301 return NULL;
35302 }
35303
35304
35305 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35306 PyObject *resultobj = NULL;
35307 wxMenu *arg1 = (wxMenu *) 0 ;
35308 wxString *arg2 = 0 ;
35309 bool temp2 = false ;
35310 PyObject * obj0 = 0 ;
35311 PyObject * obj1 = 0 ;
35312 char *kwnames[] = {
35313 (char *) "self",(char *) "title", NULL
35314 };
35315
35316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35318 if (SWIG_arg_fail(1)) SWIG_fail;
35319 {
35320 arg2 = wxString_in_helper(obj1);
35321 if (arg2 == NULL) SWIG_fail;
35322 temp2 = true;
35323 }
35324 {
35325 PyThreadState* __tstate = wxPyBeginAllowThreads();
35326 (arg1)->SetTitle((wxString const &)*arg2);
35327
35328 wxPyEndAllowThreads(__tstate);
35329 if (PyErr_Occurred()) SWIG_fail;
35330 }
35331 Py_INCREF(Py_None); resultobj = Py_None;
35332 {
35333 if (temp2)
35334 delete arg2;
35335 }
35336 return resultobj;
35337 fail:
35338 {
35339 if (temp2)
35340 delete arg2;
35341 }
35342 return NULL;
35343 }
35344
35345
35346 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35347 PyObject *resultobj = NULL;
35348 wxMenu *arg1 = (wxMenu *) 0 ;
35349 wxString result;
35350 PyObject * obj0 = 0 ;
35351 char *kwnames[] = {
35352 (char *) "self", NULL
35353 };
35354
35355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35357 if (SWIG_arg_fail(1)) SWIG_fail;
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = ((wxMenu const *)arg1)->GetTitle();
35361
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 {
35366 #if wxUSE_UNICODE
35367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35368 #else
35369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35370 #endif
35371 }
35372 return resultobj;
35373 fail:
35374 return NULL;
35375 }
35376
35377
35378 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35379 PyObject *resultobj = NULL;
35380 wxMenu *arg1 = (wxMenu *) 0 ;
35381 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35382 PyObject * obj0 = 0 ;
35383 PyObject * obj1 = 0 ;
35384 char *kwnames[] = {
35385 (char *) "self",(char *) "handler", NULL
35386 };
35387
35388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35390 if (SWIG_arg_fail(1)) SWIG_fail;
35391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35392 if (SWIG_arg_fail(2)) SWIG_fail;
35393 {
35394 PyThreadState* __tstate = wxPyBeginAllowThreads();
35395 (arg1)->SetEventHandler(arg2);
35396
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 Py_INCREF(Py_None); resultobj = Py_None;
35401 return resultobj;
35402 fail:
35403 return NULL;
35404 }
35405
35406
35407 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35408 PyObject *resultobj = NULL;
35409 wxMenu *arg1 = (wxMenu *) 0 ;
35410 wxEvtHandler *result;
35411 PyObject * obj0 = 0 ;
35412 char *kwnames[] = {
35413 (char *) "self", NULL
35414 };
35415
35416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35418 if (SWIG_arg_fail(1)) SWIG_fail;
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35422
35423 wxPyEndAllowThreads(__tstate);
35424 if (PyErr_Occurred()) SWIG_fail;
35425 }
35426 {
35427 resultobj = wxPyMake_wxObject(result, 0);
35428 }
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35436 PyObject *resultobj = NULL;
35437 wxMenu *arg1 = (wxMenu *) 0 ;
35438 wxWindow *arg2 = (wxWindow *) 0 ;
35439 PyObject * obj0 = 0 ;
35440 PyObject * obj1 = 0 ;
35441 char *kwnames[] = {
35442 (char *) "self",(char *) "win", NULL
35443 };
35444
35445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35447 if (SWIG_arg_fail(1)) SWIG_fail;
35448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35449 if (SWIG_arg_fail(2)) SWIG_fail;
35450 {
35451 PyThreadState* __tstate = wxPyBeginAllowThreads();
35452 (arg1)->SetInvokingWindow(arg2);
35453
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 Py_INCREF(Py_None); resultobj = Py_None;
35458 return resultobj;
35459 fail:
35460 return NULL;
35461 }
35462
35463
35464 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35465 PyObject *resultobj = NULL;
35466 wxMenu *arg1 = (wxMenu *) 0 ;
35467 wxWindow *result;
35468 PyObject * obj0 = 0 ;
35469 char *kwnames[] = {
35470 (char *) "self", NULL
35471 };
35472
35473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35475 if (SWIG_arg_fail(1)) SWIG_fail;
35476 {
35477 PyThreadState* __tstate = wxPyBeginAllowThreads();
35478 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35479
35480 wxPyEndAllowThreads(__tstate);
35481 if (PyErr_Occurred()) SWIG_fail;
35482 }
35483 {
35484 resultobj = wxPyMake_wxObject(result, 0);
35485 }
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35493 PyObject *resultobj = NULL;
35494 wxMenu *arg1 = (wxMenu *) 0 ;
35495 long result;
35496 PyObject * obj0 = 0 ;
35497 char *kwnames[] = {
35498 (char *) "self", NULL
35499 };
35500
35501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35503 if (SWIG_arg_fail(1)) SWIG_fail;
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 result = (long)((wxMenu const *)arg1)->GetStyle();
35507
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 {
35512 resultobj = SWIG_From_long(static_cast<long >(result));
35513 }
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj = NULL;
35522 wxMenu *arg1 = (wxMenu *) 0 ;
35523 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35524 PyObject * obj0 = 0 ;
35525 PyObject * obj1 = 0 ;
35526 char *kwnames[] = {
35527 (char *) "self",(char *) "source", NULL
35528 };
35529
35530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35532 if (SWIG_arg_fail(1)) SWIG_fail;
35533 if (obj1) {
35534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35535 if (SWIG_arg_fail(2)) SWIG_fail;
35536 }
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 (arg1)->UpdateUI(arg2);
35540
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 Py_INCREF(Py_None); resultobj = Py_None;
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj = NULL;
35553 wxMenu *arg1 = (wxMenu *) 0 ;
35554 wxMenuBar *result;
35555 PyObject * obj0 = 0 ;
35556 char *kwnames[] = {
35557 (char *) "self", NULL
35558 };
35559
35560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35562 if (SWIG_arg_fail(1)) SWIG_fail;
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35566
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 {
35571 resultobj = wxPyMake_wxObject(result, 0);
35572 }
35573 return resultobj;
35574 fail:
35575 return NULL;
35576 }
35577
35578
35579 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35580 PyObject *resultobj = NULL;
35581 wxMenu *arg1 = (wxMenu *) 0 ;
35582 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 char *kwnames[] = {
35586 (char *) "self",(char *) "menubar", NULL
35587 };
35588
35589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35591 if (SWIG_arg_fail(1)) SWIG_fail;
35592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35593 if (SWIG_arg_fail(2)) SWIG_fail;
35594 {
35595 PyThreadState* __tstate = wxPyBeginAllowThreads();
35596 (arg1)->Attach(arg2);
35597
35598 wxPyEndAllowThreads(__tstate);
35599 if (PyErr_Occurred()) SWIG_fail;
35600 }
35601 Py_INCREF(Py_None); resultobj = Py_None;
35602 return resultobj;
35603 fail:
35604 return NULL;
35605 }
35606
35607
35608 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35609 PyObject *resultobj = NULL;
35610 wxMenu *arg1 = (wxMenu *) 0 ;
35611 PyObject * obj0 = 0 ;
35612 char *kwnames[] = {
35613 (char *) "self", NULL
35614 };
35615
35616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35618 if (SWIG_arg_fail(1)) SWIG_fail;
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 (arg1)->Detach();
35622
35623 wxPyEndAllowThreads(__tstate);
35624 if (PyErr_Occurred()) SWIG_fail;
35625 }
35626 Py_INCREF(Py_None); resultobj = Py_None;
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35634 PyObject *resultobj = NULL;
35635 wxMenu *arg1 = (wxMenu *) 0 ;
35636 bool result;
35637 PyObject * obj0 = 0 ;
35638 char *kwnames[] = {
35639 (char *) "self", NULL
35640 };
35641
35642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35644 if (SWIG_arg_fail(1)) SWIG_fail;
35645 {
35646 PyThreadState* __tstate = wxPyBeginAllowThreads();
35647 result = (bool)((wxMenu const *)arg1)->IsAttached();
35648
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 {
35653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35654 }
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj = NULL;
35663 wxMenu *arg1 = (wxMenu *) 0 ;
35664 wxMenu *arg2 = (wxMenu *) 0 ;
35665 PyObject * obj0 = 0 ;
35666 PyObject * obj1 = 0 ;
35667 char *kwnames[] = {
35668 (char *) "self",(char *) "parent", NULL
35669 };
35670
35671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35673 if (SWIG_arg_fail(1)) SWIG_fail;
35674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35675 if (SWIG_arg_fail(2)) SWIG_fail;
35676 {
35677 PyThreadState* __tstate = wxPyBeginAllowThreads();
35678 (arg1)->SetParent(arg2);
35679
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 Py_INCREF(Py_None); resultobj = Py_None;
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35691 PyObject *resultobj = NULL;
35692 wxMenu *arg1 = (wxMenu *) 0 ;
35693 wxMenu *result;
35694 PyObject * obj0 = 0 ;
35695 char *kwnames[] = {
35696 (char *) "self", NULL
35697 };
35698
35699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35701 if (SWIG_arg_fail(1)) SWIG_fail;
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35705
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 {
35710 resultobj = wxPyMake_wxObject(result, 0);
35711 }
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35719 PyObject *obj;
35720 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35721 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35722 Py_INCREF(obj);
35723 return Py_BuildValue((char *)"");
35724 }
35725 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35726 PyObject *resultobj = NULL;
35727 long arg1 = (long) 0 ;
35728 wxMenuBar *result;
35729 PyObject * obj0 = 0 ;
35730 char *kwnames[] = {
35731 (char *) "style", NULL
35732 };
35733
35734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35735 if (obj0) {
35736 {
35737 arg1 = static_cast<long >(SWIG_As_long(obj0));
35738 if (SWIG_arg_fail(1)) SWIG_fail;
35739 }
35740 }
35741 {
35742 if (!wxPyCheckForApp()) SWIG_fail;
35743 PyThreadState* __tstate = wxPyBeginAllowThreads();
35744 result = (wxMenuBar *)new wxMenuBar(arg1);
35745
35746 wxPyEndAllowThreads(__tstate);
35747 if (PyErr_Occurred()) SWIG_fail;
35748 }
35749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35750 return resultobj;
35751 fail:
35752 return NULL;
35753 }
35754
35755
35756 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35757 PyObject *resultobj = NULL;
35758 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35759 wxMenu *arg2 = (wxMenu *) 0 ;
35760 wxString *arg3 = 0 ;
35761 bool result;
35762 bool temp3 = false ;
35763 PyObject * obj0 = 0 ;
35764 PyObject * obj1 = 0 ;
35765 PyObject * obj2 = 0 ;
35766 char *kwnames[] = {
35767 (char *) "self",(char *) "menu",(char *) "title", NULL
35768 };
35769
35770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35772 if (SWIG_arg_fail(1)) SWIG_fail;
35773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35774 if (SWIG_arg_fail(2)) SWIG_fail;
35775 {
35776 arg3 = wxString_in_helper(obj2);
35777 if (arg3 == NULL) SWIG_fail;
35778 temp3 = true;
35779 }
35780 {
35781 PyThreadState* __tstate = wxPyBeginAllowThreads();
35782 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35783
35784 wxPyEndAllowThreads(__tstate);
35785 if (PyErr_Occurred()) SWIG_fail;
35786 }
35787 {
35788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35789 }
35790 {
35791 if (temp3)
35792 delete arg3;
35793 }
35794 return resultobj;
35795 fail:
35796 {
35797 if (temp3)
35798 delete arg3;
35799 }
35800 return NULL;
35801 }
35802
35803
35804 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35805 PyObject *resultobj = NULL;
35806 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35807 size_t arg2 ;
35808 wxMenu *arg3 = (wxMenu *) 0 ;
35809 wxString *arg4 = 0 ;
35810 bool result;
35811 bool temp4 = false ;
35812 PyObject * obj0 = 0 ;
35813 PyObject * obj1 = 0 ;
35814 PyObject * obj2 = 0 ;
35815 PyObject * obj3 = 0 ;
35816 char *kwnames[] = {
35817 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35818 };
35819
35820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35822 if (SWIG_arg_fail(1)) SWIG_fail;
35823 {
35824 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35825 if (SWIG_arg_fail(2)) SWIG_fail;
35826 }
35827 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35828 if (SWIG_arg_fail(3)) SWIG_fail;
35829 {
35830 arg4 = wxString_in_helper(obj3);
35831 if (arg4 == NULL) SWIG_fail;
35832 temp4 = true;
35833 }
35834 {
35835 PyThreadState* __tstate = wxPyBeginAllowThreads();
35836 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35837
35838 wxPyEndAllowThreads(__tstate);
35839 if (PyErr_Occurred()) SWIG_fail;
35840 }
35841 {
35842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35843 }
35844 {
35845 if (temp4)
35846 delete arg4;
35847 }
35848 return resultobj;
35849 fail:
35850 {
35851 if (temp4)
35852 delete arg4;
35853 }
35854 return NULL;
35855 }
35856
35857
35858 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35859 PyObject *resultobj = NULL;
35860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35861 size_t result;
35862 PyObject * obj0 = 0 ;
35863 char *kwnames[] = {
35864 (char *) "self", NULL
35865 };
35866
35867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35869 if (SWIG_arg_fail(1)) SWIG_fail;
35870 {
35871 PyThreadState* __tstate = wxPyBeginAllowThreads();
35872 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35873
35874 wxPyEndAllowThreads(__tstate);
35875 if (PyErr_Occurred()) SWIG_fail;
35876 }
35877 {
35878 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35879 }
35880 return resultobj;
35881 fail:
35882 return NULL;
35883 }
35884
35885
35886 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35887 PyObject *resultobj = NULL;
35888 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35889 size_t arg2 ;
35890 wxMenu *result;
35891 PyObject * obj0 = 0 ;
35892 PyObject * obj1 = 0 ;
35893 char *kwnames[] = {
35894 (char *) "self",(char *) "pos", NULL
35895 };
35896
35897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35899 if (SWIG_arg_fail(1)) SWIG_fail;
35900 {
35901 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35902 if (SWIG_arg_fail(2)) SWIG_fail;
35903 }
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35907
35908 wxPyEndAllowThreads(__tstate);
35909 if (PyErr_Occurred()) SWIG_fail;
35910 }
35911 {
35912 resultobj = wxPyMake_wxObject(result, 0);
35913 }
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj = NULL;
35922 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35923 size_t arg2 ;
35924 wxMenu *arg3 = (wxMenu *) 0 ;
35925 wxString *arg4 = 0 ;
35926 wxMenu *result;
35927 bool temp4 = false ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 PyObject * obj2 = 0 ;
35931 PyObject * obj3 = 0 ;
35932 char *kwnames[] = {
35933 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35934 };
35935
35936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35938 if (SWIG_arg_fail(1)) SWIG_fail;
35939 {
35940 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35941 if (SWIG_arg_fail(2)) SWIG_fail;
35942 }
35943 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35944 if (SWIG_arg_fail(3)) SWIG_fail;
35945 {
35946 arg4 = wxString_in_helper(obj3);
35947 if (arg4 == NULL) SWIG_fail;
35948 temp4 = true;
35949 }
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35953
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 {
35958 resultobj = wxPyMake_wxObject(result, 0);
35959 }
35960 {
35961 if (temp4)
35962 delete arg4;
35963 }
35964 return resultobj;
35965 fail:
35966 {
35967 if (temp4)
35968 delete arg4;
35969 }
35970 return NULL;
35971 }
35972
35973
35974 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35975 PyObject *resultobj = NULL;
35976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35977 size_t arg2 ;
35978 wxMenu *result;
35979 PyObject * obj0 = 0 ;
35980 PyObject * obj1 = 0 ;
35981 char *kwnames[] = {
35982 (char *) "self",(char *) "pos", NULL
35983 };
35984
35985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35987 if (SWIG_arg_fail(1)) SWIG_fail;
35988 {
35989 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35990 if (SWIG_arg_fail(2)) SWIG_fail;
35991 }
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 result = (wxMenu *)(arg1)->Remove(arg2);
35995
35996 wxPyEndAllowThreads(__tstate);
35997 if (PyErr_Occurred()) SWIG_fail;
35998 }
35999 {
36000 resultobj = wxPyMake_wxObject(result, 0);
36001 }
36002 return resultobj;
36003 fail:
36004 return NULL;
36005 }
36006
36007
36008 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36009 PyObject *resultobj = NULL;
36010 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36011 size_t arg2 ;
36012 bool arg3 ;
36013 PyObject * obj0 = 0 ;
36014 PyObject * obj1 = 0 ;
36015 PyObject * obj2 = 0 ;
36016 char *kwnames[] = {
36017 (char *) "self",(char *) "pos",(char *) "enable", NULL
36018 };
36019
36020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36022 if (SWIG_arg_fail(1)) SWIG_fail;
36023 {
36024 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36025 if (SWIG_arg_fail(2)) SWIG_fail;
36026 }
36027 {
36028 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36029 if (SWIG_arg_fail(3)) SWIG_fail;
36030 }
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 (arg1)->EnableTop(arg2,arg3);
36034
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 Py_INCREF(Py_None); resultobj = Py_None;
36039 return resultobj;
36040 fail:
36041 return NULL;
36042 }
36043
36044
36045 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36046 PyObject *resultobj = NULL;
36047 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36048 size_t arg2 ;
36049 bool result;
36050 PyObject * obj0 = 0 ;
36051 PyObject * obj1 = 0 ;
36052 char *kwnames[] = {
36053 (char *) "self",(char *) "pos", NULL
36054 };
36055
36056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(1)) SWIG_fail;
36059 {
36060 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36061 if (SWIG_arg_fail(2)) SWIG_fail;
36062 }
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36066
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 {
36071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36072 }
36073 return resultobj;
36074 fail:
36075 return NULL;
36076 }
36077
36078
36079 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36080 PyObject *resultobj = NULL;
36081 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36082 size_t arg2 ;
36083 wxString *arg3 = 0 ;
36084 bool temp3 = false ;
36085 PyObject * obj0 = 0 ;
36086 PyObject * obj1 = 0 ;
36087 PyObject * obj2 = 0 ;
36088 char *kwnames[] = {
36089 (char *) "self",(char *) "pos",(char *) "label", NULL
36090 };
36091
36092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36094 if (SWIG_arg_fail(1)) SWIG_fail;
36095 {
36096 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36097 if (SWIG_arg_fail(2)) SWIG_fail;
36098 }
36099 {
36100 arg3 = wxString_in_helper(obj2);
36101 if (arg3 == NULL) SWIG_fail;
36102 temp3 = true;
36103 }
36104 {
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36107
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 Py_INCREF(Py_None); resultobj = Py_None;
36112 {
36113 if (temp3)
36114 delete arg3;
36115 }
36116 return resultobj;
36117 fail:
36118 {
36119 if (temp3)
36120 delete arg3;
36121 }
36122 return NULL;
36123 }
36124
36125
36126 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36127 PyObject *resultobj = NULL;
36128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36129 size_t arg2 ;
36130 wxString result;
36131 PyObject * obj0 = 0 ;
36132 PyObject * obj1 = 0 ;
36133 char *kwnames[] = {
36134 (char *) "self",(char *) "pos", NULL
36135 };
36136
36137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36139 if (SWIG_arg_fail(1)) SWIG_fail;
36140 {
36141 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36142 if (SWIG_arg_fail(2)) SWIG_fail;
36143 }
36144 {
36145 PyThreadState* __tstate = wxPyBeginAllowThreads();
36146 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36147
36148 wxPyEndAllowThreads(__tstate);
36149 if (PyErr_Occurred()) SWIG_fail;
36150 }
36151 {
36152 #if wxUSE_UNICODE
36153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36154 #else
36155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36156 #endif
36157 }
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36165 PyObject *resultobj = NULL;
36166 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36167 wxString *arg2 = 0 ;
36168 wxString *arg3 = 0 ;
36169 int result;
36170 bool temp2 = false ;
36171 bool temp3 = false ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 PyObject * obj2 = 0 ;
36175 char *kwnames[] = {
36176 (char *) "self",(char *) "menu",(char *) "item", NULL
36177 };
36178
36179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36181 if (SWIG_arg_fail(1)) SWIG_fail;
36182 {
36183 arg2 = wxString_in_helper(obj1);
36184 if (arg2 == NULL) SWIG_fail;
36185 temp2 = true;
36186 }
36187 {
36188 arg3 = wxString_in_helper(obj2);
36189 if (arg3 == NULL) SWIG_fail;
36190 temp3 = true;
36191 }
36192 {
36193 PyThreadState* __tstate = wxPyBeginAllowThreads();
36194 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36195
36196 wxPyEndAllowThreads(__tstate);
36197 if (PyErr_Occurred()) SWIG_fail;
36198 }
36199 {
36200 resultobj = SWIG_From_int(static_cast<int >(result));
36201 }
36202 {
36203 if (temp2)
36204 delete arg2;
36205 }
36206 {
36207 if (temp3)
36208 delete arg3;
36209 }
36210 return resultobj;
36211 fail:
36212 {
36213 if (temp2)
36214 delete arg2;
36215 }
36216 {
36217 if (temp3)
36218 delete arg3;
36219 }
36220 return NULL;
36221 }
36222
36223
36224 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj = NULL;
36226 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36227 int arg2 ;
36228 wxMenuItem *result;
36229 PyObject * obj0 = 0 ;
36230 PyObject * obj1 = 0 ;
36231 char *kwnames[] = {
36232 (char *) "self",(char *) "id", NULL
36233 };
36234
36235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36237 if (SWIG_arg_fail(1)) SWIG_fail;
36238 {
36239 arg2 = static_cast<int >(SWIG_As_int(obj1));
36240 if (SWIG_arg_fail(2)) SWIG_fail;
36241 }
36242 {
36243 PyThreadState* __tstate = wxPyBeginAllowThreads();
36244 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36245
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 {
36250 resultobj = wxPyMake_wxObject(result, 0);
36251 }
36252 return resultobj;
36253 fail:
36254 return NULL;
36255 }
36256
36257
36258 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36259 PyObject *resultobj = NULL;
36260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36261 wxString *arg2 = 0 ;
36262 int result;
36263 bool temp2 = false ;
36264 PyObject * obj0 = 0 ;
36265 PyObject * obj1 = 0 ;
36266 char *kwnames[] = {
36267 (char *) "self",(char *) "title", NULL
36268 };
36269
36270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36272 if (SWIG_arg_fail(1)) SWIG_fail;
36273 {
36274 arg2 = wxString_in_helper(obj1);
36275 if (arg2 == NULL) SWIG_fail;
36276 temp2 = true;
36277 }
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36281
36282 wxPyEndAllowThreads(__tstate);
36283 if (PyErr_Occurred()) SWIG_fail;
36284 }
36285 {
36286 resultobj = SWIG_From_int(static_cast<int >(result));
36287 }
36288 {
36289 if (temp2)
36290 delete arg2;
36291 }
36292 return resultobj;
36293 fail:
36294 {
36295 if (temp2)
36296 delete arg2;
36297 }
36298 return NULL;
36299 }
36300
36301
36302 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36303 PyObject *resultobj = NULL;
36304 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36305 int arg2 ;
36306 bool arg3 ;
36307 PyObject * obj0 = 0 ;
36308 PyObject * obj1 = 0 ;
36309 PyObject * obj2 = 0 ;
36310 char *kwnames[] = {
36311 (char *) "self",(char *) "id",(char *) "enable", NULL
36312 };
36313
36314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36316 if (SWIG_arg_fail(1)) SWIG_fail;
36317 {
36318 arg2 = static_cast<int >(SWIG_As_int(obj1));
36319 if (SWIG_arg_fail(2)) SWIG_fail;
36320 }
36321 {
36322 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36323 if (SWIG_arg_fail(3)) SWIG_fail;
36324 }
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 (arg1)->Enable(arg2,arg3);
36328
36329 wxPyEndAllowThreads(__tstate);
36330 if (PyErr_Occurred()) SWIG_fail;
36331 }
36332 Py_INCREF(Py_None); resultobj = Py_None;
36333 return resultobj;
36334 fail:
36335 return NULL;
36336 }
36337
36338
36339 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36340 PyObject *resultobj = NULL;
36341 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36342 int arg2 ;
36343 bool arg3 ;
36344 PyObject * obj0 = 0 ;
36345 PyObject * obj1 = 0 ;
36346 PyObject * obj2 = 0 ;
36347 char *kwnames[] = {
36348 (char *) "self",(char *) "id",(char *) "check", NULL
36349 };
36350
36351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36353 if (SWIG_arg_fail(1)) SWIG_fail;
36354 {
36355 arg2 = static_cast<int >(SWIG_As_int(obj1));
36356 if (SWIG_arg_fail(2)) SWIG_fail;
36357 }
36358 {
36359 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36360 if (SWIG_arg_fail(3)) SWIG_fail;
36361 }
36362 {
36363 PyThreadState* __tstate = wxPyBeginAllowThreads();
36364 (arg1)->Check(arg2,arg3);
36365
36366 wxPyEndAllowThreads(__tstate);
36367 if (PyErr_Occurred()) SWIG_fail;
36368 }
36369 Py_INCREF(Py_None); resultobj = Py_None;
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36377 PyObject *resultobj = NULL;
36378 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36379 int arg2 ;
36380 bool result;
36381 PyObject * obj0 = 0 ;
36382 PyObject * obj1 = 0 ;
36383 char *kwnames[] = {
36384 (char *) "self",(char *) "id", NULL
36385 };
36386
36387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36389 if (SWIG_arg_fail(1)) SWIG_fail;
36390 {
36391 arg2 = static_cast<int >(SWIG_As_int(obj1));
36392 if (SWIG_arg_fail(2)) SWIG_fail;
36393 }
36394 {
36395 PyThreadState* __tstate = wxPyBeginAllowThreads();
36396 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36397
36398 wxPyEndAllowThreads(__tstate);
36399 if (PyErr_Occurred()) SWIG_fail;
36400 }
36401 {
36402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36403 }
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36411 PyObject *resultobj = NULL;
36412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36413 int arg2 ;
36414 bool result;
36415 PyObject * obj0 = 0 ;
36416 PyObject * obj1 = 0 ;
36417 char *kwnames[] = {
36418 (char *) "self",(char *) "id", NULL
36419 };
36420
36421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36423 if (SWIG_arg_fail(1)) SWIG_fail;
36424 {
36425 arg2 = static_cast<int >(SWIG_As_int(obj1));
36426 if (SWIG_arg_fail(2)) SWIG_fail;
36427 }
36428 {
36429 PyThreadState* __tstate = wxPyBeginAllowThreads();
36430 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36431
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 {
36436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36437 }
36438 return resultobj;
36439 fail:
36440 return NULL;
36441 }
36442
36443
36444 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36445 PyObject *resultobj = NULL;
36446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36447 int arg2 ;
36448 wxString *arg3 = 0 ;
36449 bool temp3 = false ;
36450 PyObject * obj0 = 0 ;
36451 PyObject * obj1 = 0 ;
36452 PyObject * obj2 = 0 ;
36453 char *kwnames[] = {
36454 (char *) "self",(char *) "id",(char *) "label", NULL
36455 };
36456
36457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36459 if (SWIG_arg_fail(1)) SWIG_fail;
36460 {
36461 arg2 = static_cast<int >(SWIG_As_int(obj1));
36462 if (SWIG_arg_fail(2)) SWIG_fail;
36463 }
36464 {
36465 arg3 = wxString_in_helper(obj2);
36466 if (arg3 == NULL) SWIG_fail;
36467 temp3 = true;
36468 }
36469 {
36470 PyThreadState* __tstate = wxPyBeginAllowThreads();
36471 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36472
36473 wxPyEndAllowThreads(__tstate);
36474 if (PyErr_Occurred()) SWIG_fail;
36475 }
36476 Py_INCREF(Py_None); resultobj = Py_None;
36477 {
36478 if (temp3)
36479 delete arg3;
36480 }
36481 return resultobj;
36482 fail:
36483 {
36484 if (temp3)
36485 delete arg3;
36486 }
36487 return NULL;
36488 }
36489
36490
36491 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36492 PyObject *resultobj = NULL;
36493 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36494 int arg2 ;
36495 wxString result;
36496 PyObject * obj0 = 0 ;
36497 PyObject * obj1 = 0 ;
36498 char *kwnames[] = {
36499 (char *) "self",(char *) "id", NULL
36500 };
36501
36502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36504 if (SWIG_arg_fail(1)) SWIG_fail;
36505 {
36506 arg2 = static_cast<int >(SWIG_As_int(obj1));
36507 if (SWIG_arg_fail(2)) SWIG_fail;
36508 }
36509 {
36510 PyThreadState* __tstate = wxPyBeginAllowThreads();
36511 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36512
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 {
36517 #if wxUSE_UNICODE
36518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36519 #else
36520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36521 #endif
36522 }
36523 return resultobj;
36524 fail:
36525 return NULL;
36526 }
36527
36528
36529 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36530 PyObject *resultobj = NULL;
36531 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36532 int arg2 ;
36533 wxString *arg3 = 0 ;
36534 bool temp3 = false ;
36535 PyObject * obj0 = 0 ;
36536 PyObject * obj1 = 0 ;
36537 PyObject * obj2 = 0 ;
36538 char *kwnames[] = {
36539 (char *) "self",(char *) "id",(char *) "helpString", NULL
36540 };
36541
36542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36544 if (SWIG_arg_fail(1)) SWIG_fail;
36545 {
36546 arg2 = static_cast<int >(SWIG_As_int(obj1));
36547 if (SWIG_arg_fail(2)) SWIG_fail;
36548 }
36549 {
36550 arg3 = wxString_in_helper(obj2);
36551 if (arg3 == NULL) SWIG_fail;
36552 temp3 = true;
36553 }
36554 {
36555 PyThreadState* __tstate = wxPyBeginAllowThreads();
36556 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36557
36558 wxPyEndAllowThreads(__tstate);
36559 if (PyErr_Occurred()) SWIG_fail;
36560 }
36561 Py_INCREF(Py_None); resultobj = Py_None;
36562 {
36563 if (temp3)
36564 delete arg3;
36565 }
36566 return resultobj;
36567 fail:
36568 {
36569 if (temp3)
36570 delete arg3;
36571 }
36572 return NULL;
36573 }
36574
36575
36576 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36577 PyObject *resultobj = NULL;
36578 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36579 int arg2 ;
36580 wxString result;
36581 PyObject * obj0 = 0 ;
36582 PyObject * obj1 = 0 ;
36583 char *kwnames[] = {
36584 (char *) "self",(char *) "id", NULL
36585 };
36586
36587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36589 if (SWIG_arg_fail(1)) SWIG_fail;
36590 {
36591 arg2 = static_cast<int >(SWIG_As_int(obj1));
36592 if (SWIG_arg_fail(2)) SWIG_fail;
36593 }
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36597
36598 wxPyEndAllowThreads(__tstate);
36599 if (PyErr_Occurred()) SWIG_fail;
36600 }
36601 {
36602 #if wxUSE_UNICODE
36603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36604 #else
36605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36606 #endif
36607 }
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36615 PyObject *resultobj = NULL;
36616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36617 wxFrame *result;
36618 PyObject * obj0 = 0 ;
36619 char *kwnames[] = {
36620 (char *) "self", NULL
36621 };
36622
36623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36625 if (SWIG_arg_fail(1)) SWIG_fail;
36626 {
36627 PyThreadState* __tstate = wxPyBeginAllowThreads();
36628 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36629
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 {
36634 resultobj = wxPyMake_wxObject(result, 0);
36635 }
36636 return resultobj;
36637 fail:
36638 return NULL;
36639 }
36640
36641
36642 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36643 PyObject *resultobj = NULL;
36644 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36645 bool result;
36646 PyObject * obj0 = 0 ;
36647 char *kwnames[] = {
36648 (char *) "self", NULL
36649 };
36650
36651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36653 if (SWIG_arg_fail(1)) SWIG_fail;
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36657
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 {
36662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36663 }
36664 return resultobj;
36665 fail:
36666 return NULL;
36667 }
36668
36669
36670 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36671 PyObject *resultobj = NULL;
36672 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36673 wxFrame *arg2 = (wxFrame *) 0 ;
36674 PyObject * obj0 = 0 ;
36675 PyObject * obj1 = 0 ;
36676 char *kwnames[] = {
36677 (char *) "self",(char *) "frame", NULL
36678 };
36679
36680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36682 if (SWIG_arg_fail(1)) SWIG_fail;
36683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36684 if (SWIG_arg_fail(2)) SWIG_fail;
36685 {
36686 PyThreadState* __tstate = wxPyBeginAllowThreads();
36687 (arg1)->Attach(arg2);
36688
36689 wxPyEndAllowThreads(__tstate);
36690 if (PyErr_Occurred()) SWIG_fail;
36691 }
36692 Py_INCREF(Py_None); resultobj = Py_None;
36693 return resultobj;
36694 fail:
36695 return NULL;
36696 }
36697
36698
36699 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36700 PyObject *resultobj = NULL;
36701 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36702 PyObject * obj0 = 0 ;
36703 char *kwnames[] = {
36704 (char *) "self", NULL
36705 };
36706
36707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36709 if (SWIG_arg_fail(1)) SWIG_fail;
36710 {
36711 PyThreadState* __tstate = wxPyBeginAllowThreads();
36712 (arg1)->Detach();
36713
36714 wxPyEndAllowThreads(__tstate);
36715 if (PyErr_Occurred()) SWIG_fail;
36716 }
36717 Py_INCREF(Py_None); resultobj = Py_None;
36718 return resultobj;
36719 fail:
36720 return NULL;
36721 }
36722
36723
36724 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36725 PyObject *resultobj = NULL;
36726 bool arg1 ;
36727 PyObject * obj0 = 0 ;
36728 char *kwnames[] = {
36729 (char *) "enable", NULL
36730 };
36731
36732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36733 {
36734 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36735 if (SWIG_arg_fail(1)) SWIG_fail;
36736 }
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 wxMenuBar_SetAutoWindowMenu(arg1);
36740
36741 wxPyEndAllowThreads(__tstate);
36742 if (PyErr_Occurred()) SWIG_fail;
36743 }
36744 Py_INCREF(Py_None); resultobj = Py_None;
36745 return resultobj;
36746 fail:
36747 return NULL;
36748 }
36749
36750
36751 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36752 PyObject *resultobj = NULL;
36753 bool result;
36754 char *kwnames[] = {
36755 NULL
36756 };
36757
36758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 result = (bool)wxMenuBar_GetAutoWindowMenu();
36762
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 {
36767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36768 }
36769 return resultobj;
36770 fail:
36771 return NULL;
36772 }
36773
36774
36775 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36776 PyObject *obj;
36777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36778 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36779 Py_INCREF(obj);
36780 return Py_BuildValue((char *)"");
36781 }
36782 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36783 PyObject *resultobj = NULL;
36784 wxMenu *arg1 = (wxMenu *) NULL ;
36785 int arg2 = (int) wxID_ANY ;
36786 wxString const &arg3_defvalue = wxPyEmptyString ;
36787 wxString *arg3 = (wxString *) &arg3_defvalue ;
36788 wxString const &arg4_defvalue = wxPyEmptyString ;
36789 wxString *arg4 = (wxString *) &arg4_defvalue ;
36790 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36791 wxMenu *arg6 = (wxMenu *) NULL ;
36792 wxMenuItem *result;
36793 bool temp3 = false ;
36794 bool temp4 = false ;
36795 PyObject * obj0 = 0 ;
36796 PyObject * obj1 = 0 ;
36797 PyObject * obj2 = 0 ;
36798 PyObject * obj3 = 0 ;
36799 PyObject * obj4 = 0 ;
36800 PyObject * obj5 = 0 ;
36801 char *kwnames[] = {
36802 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36803 };
36804
36805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36806 if (obj0) {
36807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36808 if (SWIG_arg_fail(1)) SWIG_fail;
36809 }
36810 if (obj1) {
36811 {
36812 arg2 = static_cast<int >(SWIG_As_int(obj1));
36813 if (SWIG_arg_fail(2)) SWIG_fail;
36814 }
36815 }
36816 if (obj2) {
36817 {
36818 arg3 = wxString_in_helper(obj2);
36819 if (arg3 == NULL) SWIG_fail;
36820 temp3 = true;
36821 }
36822 }
36823 if (obj3) {
36824 {
36825 arg4 = wxString_in_helper(obj3);
36826 if (arg4 == NULL) SWIG_fail;
36827 temp4 = true;
36828 }
36829 }
36830 if (obj4) {
36831 {
36832 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36833 if (SWIG_arg_fail(5)) SWIG_fail;
36834 }
36835 }
36836 if (obj5) {
36837 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36838 if (SWIG_arg_fail(6)) SWIG_fail;
36839 }
36840 {
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36843
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 {
36848 resultobj = wxPyMake_wxObject(result, 1);
36849 }
36850 {
36851 if (temp3)
36852 delete arg3;
36853 }
36854 {
36855 if (temp4)
36856 delete arg4;
36857 }
36858 return resultobj;
36859 fail:
36860 {
36861 if (temp3)
36862 delete arg3;
36863 }
36864 {
36865 if (temp4)
36866 delete arg4;
36867 }
36868 return NULL;
36869 }
36870
36871
36872 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36873 PyObject *resultobj = NULL;
36874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36875 wxMenu *result;
36876 PyObject * obj0 = 0 ;
36877 char *kwnames[] = {
36878 (char *) "self", NULL
36879 };
36880
36881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36883 if (SWIG_arg_fail(1)) SWIG_fail;
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36887
36888 wxPyEndAllowThreads(__tstate);
36889 if (PyErr_Occurred()) SWIG_fail;
36890 }
36891 {
36892 resultobj = wxPyMake_wxObject(result, 0);
36893 }
36894 return resultobj;
36895 fail:
36896 return NULL;
36897 }
36898
36899
36900 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36901 PyObject *resultobj = NULL;
36902 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36903 wxMenu *arg2 = (wxMenu *) 0 ;
36904 PyObject * obj0 = 0 ;
36905 PyObject * obj1 = 0 ;
36906 char *kwnames[] = {
36907 (char *) "self",(char *) "menu", NULL
36908 };
36909
36910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36912 if (SWIG_arg_fail(1)) SWIG_fail;
36913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36914 if (SWIG_arg_fail(2)) SWIG_fail;
36915 {
36916 PyThreadState* __tstate = wxPyBeginAllowThreads();
36917 (arg1)->SetMenu(arg2);
36918
36919 wxPyEndAllowThreads(__tstate);
36920 if (PyErr_Occurred()) SWIG_fail;
36921 }
36922 Py_INCREF(Py_None); resultobj = Py_None;
36923 return resultobj;
36924 fail:
36925 return NULL;
36926 }
36927
36928
36929 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36930 PyObject *resultobj = NULL;
36931 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36932 int arg2 ;
36933 PyObject * obj0 = 0 ;
36934 PyObject * obj1 = 0 ;
36935 char *kwnames[] = {
36936 (char *) "self",(char *) "id", NULL
36937 };
36938
36939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36941 if (SWIG_arg_fail(1)) SWIG_fail;
36942 {
36943 arg2 = static_cast<int >(SWIG_As_int(obj1));
36944 if (SWIG_arg_fail(2)) SWIG_fail;
36945 }
36946 {
36947 PyThreadState* __tstate = wxPyBeginAllowThreads();
36948 (arg1)->SetId(arg2);
36949
36950 wxPyEndAllowThreads(__tstate);
36951 if (PyErr_Occurred()) SWIG_fail;
36952 }
36953 Py_INCREF(Py_None); resultobj = Py_None;
36954 return resultobj;
36955 fail:
36956 return NULL;
36957 }
36958
36959
36960 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36961 PyObject *resultobj = NULL;
36962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36963 int result;
36964 PyObject * obj0 = 0 ;
36965 char *kwnames[] = {
36966 (char *) "self", NULL
36967 };
36968
36969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(1)) SWIG_fail;
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 result = (int)((wxMenuItem const *)arg1)->GetId();
36975
36976 wxPyEndAllowThreads(__tstate);
36977 if (PyErr_Occurred()) SWIG_fail;
36978 }
36979 {
36980 resultobj = SWIG_From_int(static_cast<int >(result));
36981 }
36982 return resultobj;
36983 fail:
36984 return NULL;
36985 }
36986
36987
36988 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36989 PyObject *resultobj = NULL;
36990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36991 bool result;
36992 PyObject * obj0 = 0 ;
36993 char *kwnames[] = {
36994 (char *) "self", NULL
36995 };
36996
36997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36999 if (SWIG_arg_fail(1)) SWIG_fail;
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
37003
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37009 }
37010 return resultobj;
37011 fail:
37012 return NULL;
37013 }
37014
37015
37016 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37017 PyObject *resultobj = NULL;
37018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37019 wxString *arg2 = 0 ;
37020 bool temp2 = false ;
37021 PyObject * obj0 = 0 ;
37022 PyObject * obj1 = 0 ;
37023 char *kwnames[] = {
37024 (char *) "self",(char *) "str", NULL
37025 };
37026
37027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37029 if (SWIG_arg_fail(1)) SWIG_fail;
37030 {
37031 arg2 = wxString_in_helper(obj1);
37032 if (arg2 == NULL) SWIG_fail;
37033 temp2 = true;
37034 }
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 (arg1)->SetText((wxString const &)*arg2);
37038
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 Py_INCREF(Py_None); resultobj = Py_None;
37043 {
37044 if (temp2)
37045 delete arg2;
37046 }
37047 return resultobj;
37048 fail:
37049 {
37050 if (temp2)
37051 delete arg2;
37052 }
37053 return NULL;
37054 }
37055
37056
37057 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37058 PyObject *resultobj = NULL;
37059 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37060 wxString result;
37061 PyObject * obj0 = 0 ;
37062 char *kwnames[] = {
37063 (char *) "self", NULL
37064 };
37065
37066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37068 if (SWIG_arg_fail(1)) SWIG_fail;
37069 {
37070 PyThreadState* __tstate = wxPyBeginAllowThreads();
37071 result = ((wxMenuItem const *)arg1)->GetLabel();
37072
37073 wxPyEndAllowThreads(__tstate);
37074 if (PyErr_Occurred()) SWIG_fail;
37075 }
37076 {
37077 #if wxUSE_UNICODE
37078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37079 #else
37080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37081 #endif
37082 }
37083 return resultobj;
37084 fail:
37085 return NULL;
37086 }
37087
37088
37089 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37090 PyObject *resultobj = NULL;
37091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37092 wxString *result;
37093 PyObject * obj0 = 0 ;
37094 char *kwnames[] = {
37095 (char *) "self", NULL
37096 };
37097
37098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37100 if (SWIG_arg_fail(1)) SWIG_fail;
37101 {
37102 PyThreadState* __tstate = wxPyBeginAllowThreads();
37103 {
37104 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37105 result = (wxString *) &_result_ref;
37106 }
37107
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 {
37112 #if wxUSE_UNICODE
37113 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37114 #else
37115 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37116 #endif
37117 }
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj = NULL;
37126 wxString *arg1 = 0 ;
37127 wxString result;
37128 bool temp1 = false ;
37129 PyObject * obj0 = 0 ;
37130 char *kwnames[] = {
37131 (char *) "text", NULL
37132 };
37133
37134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37135 {
37136 arg1 = wxString_in_helper(obj0);
37137 if (arg1 == NULL) SWIG_fail;
37138 temp1 = true;
37139 }
37140 {
37141 PyThreadState* __tstate = wxPyBeginAllowThreads();
37142 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37143
37144 wxPyEndAllowThreads(__tstate);
37145 if (PyErr_Occurred()) SWIG_fail;
37146 }
37147 {
37148 #if wxUSE_UNICODE
37149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37150 #else
37151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37152 #endif
37153 }
37154 {
37155 if (temp1)
37156 delete arg1;
37157 }
37158 return resultobj;
37159 fail:
37160 {
37161 if (temp1)
37162 delete arg1;
37163 }
37164 return NULL;
37165 }
37166
37167
37168 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj = NULL;
37170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37171 wxItemKind result;
37172 PyObject * obj0 = 0 ;
37173 char *kwnames[] = {
37174 (char *) "self", NULL
37175 };
37176
37177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37179 if (SWIG_arg_fail(1)) SWIG_fail;
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37183
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 resultobj = SWIG_From_int((result));
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37195 PyObject *resultobj = NULL;
37196 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37197 wxItemKind arg2 ;
37198 PyObject * obj0 = 0 ;
37199 PyObject * obj1 = 0 ;
37200 char *kwnames[] = {
37201 (char *) "self",(char *) "kind", NULL
37202 };
37203
37204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37206 if (SWIG_arg_fail(1)) SWIG_fail;
37207 {
37208 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37209 if (SWIG_arg_fail(2)) SWIG_fail;
37210 }
37211 {
37212 PyThreadState* __tstate = wxPyBeginAllowThreads();
37213 (arg1)->SetKind(arg2);
37214
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 Py_INCREF(Py_None); resultobj = Py_None;
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37226 PyObject *resultobj = NULL;
37227 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37228 bool arg2 ;
37229 PyObject * obj0 = 0 ;
37230 PyObject * obj1 = 0 ;
37231 char *kwnames[] = {
37232 (char *) "self",(char *) "checkable", NULL
37233 };
37234
37235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37237 if (SWIG_arg_fail(1)) SWIG_fail;
37238 {
37239 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37240 if (SWIG_arg_fail(2)) SWIG_fail;
37241 }
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 (arg1)->SetCheckable(arg2);
37245
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 Py_INCREF(Py_None); resultobj = Py_None;
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj = NULL;
37258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37259 bool result;
37260 PyObject * obj0 = 0 ;
37261 char *kwnames[] = {
37262 (char *) "self", NULL
37263 };
37264
37265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37267 if (SWIG_arg_fail(1)) SWIG_fail;
37268 {
37269 PyThreadState* __tstate = wxPyBeginAllowThreads();
37270 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37271
37272 wxPyEndAllowThreads(__tstate);
37273 if (PyErr_Occurred()) SWIG_fail;
37274 }
37275 {
37276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37277 }
37278 return resultobj;
37279 fail:
37280 return NULL;
37281 }
37282
37283
37284 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37285 PyObject *resultobj = NULL;
37286 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37287 bool result;
37288 PyObject * obj0 = 0 ;
37289 char *kwnames[] = {
37290 (char *) "self", NULL
37291 };
37292
37293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37295 if (SWIG_arg_fail(1)) SWIG_fail;
37296 {
37297 PyThreadState* __tstate = wxPyBeginAllowThreads();
37298 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37299
37300 wxPyEndAllowThreads(__tstate);
37301 if (PyErr_Occurred()) SWIG_fail;
37302 }
37303 {
37304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37305 }
37306 return resultobj;
37307 fail:
37308 return NULL;
37309 }
37310
37311
37312 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37313 PyObject *resultobj = NULL;
37314 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37315 wxMenu *arg2 = (wxMenu *) 0 ;
37316 PyObject * obj0 = 0 ;
37317 PyObject * obj1 = 0 ;
37318 char *kwnames[] = {
37319 (char *) "self",(char *) "menu", NULL
37320 };
37321
37322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37324 if (SWIG_arg_fail(1)) SWIG_fail;
37325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37326 if (SWIG_arg_fail(2)) SWIG_fail;
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 (arg1)->SetSubMenu(arg2);
37330
37331 wxPyEndAllowThreads(__tstate);
37332 if (PyErr_Occurred()) SWIG_fail;
37333 }
37334 Py_INCREF(Py_None); resultobj = Py_None;
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37342 PyObject *resultobj = NULL;
37343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37344 wxMenu *result;
37345 PyObject * obj0 = 0 ;
37346 char *kwnames[] = {
37347 (char *) "self", NULL
37348 };
37349
37350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37352 if (SWIG_arg_fail(1)) SWIG_fail;
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37356
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 {
37361 resultobj = wxPyMake_wxObject(result, 0);
37362 }
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj = NULL;
37371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37372 bool arg2 = (bool) true ;
37373 PyObject * obj0 = 0 ;
37374 PyObject * obj1 = 0 ;
37375 char *kwnames[] = {
37376 (char *) "self",(char *) "enable", NULL
37377 };
37378
37379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37381 if (SWIG_arg_fail(1)) SWIG_fail;
37382 if (obj1) {
37383 {
37384 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37385 if (SWIG_arg_fail(2)) SWIG_fail;
37386 }
37387 }
37388 {
37389 PyThreadState* __tstate = wxPyBeginAllowThreads();
37390 (arg1)->Enable(arg2);
37391
37392 wxPyEndAllowThreads(__tstate);
37393 if (PyErr_Occurred()) SWIG_fail;
37394 }
37395 Py_INCREF(Py_None); resultobj = Py_None;
37396 return resultobj;
37397 fail:
37398 return NULL;
37399 }
37400
37401
37402 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37403 PyObject *resultobj = NULL;
37404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37405 bool result;
37406 PyObject * obj0 = 0 ;
37407 char *kwnames[] = {
37408 (char *) "self", NULL
37409 };
37410
37411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37413 if (SWIG_arg_fail(1)) SWIG_fail;
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37417
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 {
37422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37423 }
37424 return resultobj;
37425 fail:
37426 return NULL;
37427 }
37428
37429
37430 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37431 PyObject *resultobj = NULL;
37432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37433 bool arg2 = (bool) true ;
37434 PyObject * obj0 = 0 ;
37435 PyObject * obj1 = 0 ;
37436 char *kwnames[] = {
37437 (char *) "self",(char *) "check", NULL
37438 };
37439
37440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37442 if (SWIG_arg_fail(1)) SWIG_fail;
37443 if (obj1) {
37444 {
37445 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37446 if (SWIG_arg_fail(2)) SWIG_fail;
37447 }
37448 }
37449 {
37450 PyThreadState* __tstate = wxPyBeginAllowThreads();
37451 (arg1)->Check(arg2);
37452
37453 wxPyEndAllowThreads(__tstate);
37454 if (PyErr_Occurred()) SWIG_fail;
37455 }
37456 Py_INCREF(Py_None); resultobj = Py_None;
37457 return resultobj;
37458 fail:
37459 return NULL;
37460 }
37461
37462
37463 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37464 PyObject *resultobj = NULL;
37465 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37466 bool result;
37467 PyObject * obj0 = 0 ;
37468 char *kwnames[] = {
37469 (char *) "self", NULL
37470 };
37471
37472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37474 if (SWIG_arg_fail(1)) SWIG_fail;
37475 {
37476 PyThreadState* __tstate = wxPyBeginAllowThreads();
37477 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37478
37479 wxPyEndAllowThreads(__tstate);
37480 if (PyErr_Occurred()) SWIG_fail;
37481 }
37482 {
37483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37484 }
37485 return resultobj;
37486 fail:
37487 return NULL;
37488 }
37489
37490
37491 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37492 PyObject *resultobj = NULL;
37493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37494 PyObject * obj0 = 0 ;
37495 char *kwnames[] = {
37496 (char *) "self", NULL
37497 };
37498
37499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37501 if (SWIG_arg_fail(1)) SWIG_fail;
37502 {
37503 PyThreadState* __tstate = wxPyBeginAllowThreads();
37504 (arg1)->Toggle();
37505
37506 wxPyEndAllowThreads(__tstate);
37507 if (PyErr_Occurred()) SWIG_fail;
37508 }
37509 Py_INCREF(Py_None); resultobj = Py_None;
37510 return resultobj;
37511 fail:
37512 return NULL;
37513 }
37514
37515
37516 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj = NULL;
37518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37519 wxString *arg2 = 0 ;
37520 bool temp2 = false ;
37521 PyObject * obj0 = 0 ;
37522 PyObject * obj1 = 0 ;
37523 char *kwnames[] = {
37524 (char *) "self",(char *) "str", NULL
37525 };
37526
37527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37529 if (SWIG_arg_fail(1)) SWIG_fail;
37530 {
37531 arg2 = wxString_in_helper(obj1);
37532 if (arg2 == NULL) SWIG_fail;
37533 temp2 = true;
37534 }
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 (arg1)->SetHelp((wxString const &)*arg2);
37538
37539 wxPyEndAllowThreads(__tstate);
37540 if (PyErr_Occurred()) SWIG_fail;
37541 }
37542 Py_INCREF(Py_None); resultobj = Py_None;
37543 {
37544 if (temp2)
37545 delete arg2;
37546 }
37547 return resultobj;
37548 fail:
37549 {
37550 if (temp2)
37551 delete arg2;
37552 }
37553 return NULL;
37554 }
37555
37556
37557 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37558 PyObject *resultobj = NULL;
37559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37560 wxString *result;
37561 PyObject * obj0 = 0 ;
37562 char *kwnames[] = {
37563 (char *) "self", NULL
37564 };
37565
37566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37568 if (SWIG_arg_fail(1)) SWIG_fail;
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 {
37572 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37573 result = (wxString *) &_result_ref;
37574 }
37575
37576 wxPyEndAllowThreads(__tstate);
37577 if (PyErr_Occurred()) SWIG_fail;
37578 }
37579 {
37580 #if wxUSE_UNICODE
37581 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37582 #else
37583 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37584 #endif
37585 }
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37593 PyObject *resultobj = NULL;
37594 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37595 wxAcceleratorEntry *result;
37596 PyObject * obj0 = 0 ;
37597 char *kwnames[] = {
37598 (char *) "self", NULL
37599 };
37600
37601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37603 if (SWIG_arg_fail(1)) SWIG_fail;
37604 {
37605 PyThreadState* __tstate = wxPyBeginAllowThreads();
37606 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37607
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37612 return resultobj;
37613 fail:
37614 return NULL;
37615 }
37616
37617
37618 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37619 PyObject *resultobj = NULL;
37620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37621 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37622 PyObject * obj0 = 0 ;
37623 PyObject * obj1 = 0 ;
37624 char *kwnames[] = {
37625 (char *) "self",(char *) "accel", NULL
37626 };
37627
37628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37630 if (SWIG_arg_fail(1)) SWIG_fail;
37631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37632 if (SWIG_arg_fail(2)) SWIG_fail;
37633 {
37634 PyThreadState* __tstate = wxPyBeginAllowThreads();
37635 (arg1)->SetAccel(arg2);
37636
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 Py_INCREF(Py_None); resultobj = Py_None;
37641 return resultobj;
37642 fail:
37643 return NULL;
37644 }
37645
37646
37647 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37648 PyObject *resultobj = NULL;
37649 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37650 wxBitmap *arg2 = 0 ;
37651 PyObject * obj0 = 0 ;
37652 PyObject * obj1 = 0 ;
37653 char *kwnames[] = {
37654 (char *) "self",(char *) "bitmap", NULL
37655 };
37656
37657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37659 if (SWIG_arg_fail(1)) SWIG_fail;
37660 {
37661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37662 if (SWIG_arg_fail(2)) SWIG_fail;
37663 if (arg2 == NULL) {
37664 SWIG_null_ref("wxBitmap");
37665 }
37666 if (SWIG_arg_fail(2)) SWIG_fail;
37667 }
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37671
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 Py_INCREF(Py_None); resultobj = Py_None;
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37683 PyObject *resultobj = NULL;
37684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37685 wxBitmap *result;
37686 PyObject * obj0 = 0 ;
37687 char *kwnames[] = {
37688 (char *) "self", NULL
37689 };
37690
37691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37693 if (SWIG_arg_fail(1)) SWIG_fail;
37694 {
37695 PyThreadState* __tstate = wxPyBeginAllowThreads();
37696 {
37697 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37698 result = (wxBitmap *) &_result_ref;
37699 }
37700
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 {
37705 wxBitmap* resultptr = new wxBitmap(*result);
37706 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37707 }
37708 return resultobj;
37709 fail:
37710 return NULL;
37711 }
37712
37713
37714 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37715 PyObject *resultobj = NULL;
37716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37717 wxFont *arg2 = 0 ;
37718 PyObject * obj0 = 0 ;
37719 PyObject * obj1 = 0 ;
37720 char *kwnames[] = {
37721 (char *) "self",(char *) "font", NULL
37722 };
37723
37724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37726 if (SWIG_arg_fail(1)) SWIG_fail;
37727 {
37728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37729 if (SWIG_arg_fail(2)) SWIG_fail;
37730 if (arg2 == NULL) {
37731 SWIG_null_ref("wxFont");
37732 }
37733 if (SWIG_arg_fail(2)) SWIG_fail;
37734 }
37735 {
37736 PyThreadState* __tstate = wxPyBeginAllowThreads();
37737 (arg1)->SetFont((wxFont const &)*arg2);
37738
37739 wxPyEndAllowThreads(__tstate);
37740 if (PyErr_Occurred()) SWIG_fail;
37741 }
37742 Py_INCREF(Py_None); resultobj = Py_None;
37743 return resultobj;
37744 fail:
37745 return NULL;
37746 }
37747
37748
37749 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37750 PyObject *resultobj = NULL;
37751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37752 wxFont result;
37753 PyObject * obj0 = 0 ;
37754 char *kwnames[] = {
37755 (char *) "self", NULL
37756 };
37757
37758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37760 if (SWIG_arg_fail(1)) SWIG_fail;
37761 {
37762 PyThreadState* __tstate = wxPyBeginAllowThreads();
37763 result = (arg1)->GetFont();
37764
37765 wxPyEndAllowThreads(__tstate);
37766 if (PyErr_Occurred()) SWIG_fail;
37767 }
37768 {
37769 wxFont * resultptr;
37770 resultptr = new wxFont(static_cast<wxFont & >(result));
37771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37772 }
37773 return resultobj;
37774 fail:
37775 return NULL;
37776 }
37777
37778
37779 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37780 PyObject *resultobj = NULL;
37781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37782 wxColour *arg2 = 0 ;
37783 wxColour temp2 ;
37784 PyObject * obj0 = 0 ;
37785 PyObject * obj1 = 0 ;
37786 char *kwnames[] = {
37787 (char *) "self",(char *) "colText", NULL
37788 };
37789
37790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37792 if (SWIG_arg_fail(1)) SWIG_fail;
37793 {
37794 arg2 = &temp2;
37795 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37796 }
37797 {
37798 PyThreadState* __tstate = wxPyBeginAllowThreads();
37799 (arg1)->SetTextColour((wxColour const &)*arg2);
37800
37801 wxPyEndAllowThreads(__tstate);
37802 if (PyErr_Occurred()) SWIG_fail;
37803 }
37804 Py_INCREF(Py_None); resultobj = Py_None;
37805 return resultobj;
37806 fail:
37807 return NULL;
37808 }
37809
37810
37811 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37812 PyObject *resultobj = NULL;
37813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37814 wxColour result;
37815 PyObject * obj0 = 0 ;
37816 char *kwnames[] = {
37817 (char *) "self", NULL
37818 };
37819
37820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37822 if (SWIG_arg_fail(1)) SWIG_fail;
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 result = (arg1)->GetTextColour();
37826
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 {
37831 wxColour * resultptr;
37832 resultptr = new wxColour(static_cast<wxColour & >(result));
37833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37834 }
37835 return resultobj;
37836 fail:
37837 return NULL;
37838 }
37839
37840
37841 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37842 PyObject *resultobj = NULL;
37843 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37844 wxColour *arg2 = 0 ;
37845 wxColour temp2 ;
37846 PyObject * obj0 = 0 ;
37847 PyObject * obj1 = 0 ;
37848 char *kwnames[] = {
37849 (char *) "self",(char *) "colBack", NULL
37850 };
37851
37852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37854 if (SWIG_arg_fail(1)) SWIG_fail;
37855 {
37856 arg2 = &temp2;
37857 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37858 }
37859 {
37860 PyThreadState* __tstate = wxPyBeginAllowThreads();
37861 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
37862
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 Py_INCREF(Py_None); resultobj = Py_None;
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37874 PyObject *resultobj = NULL;
37875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37876 wxColour result;
37877 PyObject * obj0 = 0 ;
37878 char *kwnames[] = {
37879 (char *) "self", NULL
37880 };
37881
37882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37884 if (SWIG_arg_fail(1)) SWIG_fail;
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 result = (arg1)->GetBackgroundColour();
37888
37889 wxPyEndAllowThreads(__tstate);
37890 if (PyErr_Occurred()) SWIG_fail;
37891 }
37892 {
37893 wxColour * resultptr;
37894 resultptr = new wxColour(static_cast<wxColour & >(result));
37895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37896 }
37897 return resultobj;
37898 fail:
37899 return NULL;
37900 }
37901
37902
37903 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37904 PyObject *resultobj = NULL;
37905 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37906 wxBitmap *arg2 = 0 ;
37907 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37908 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37909 PyObject * obj0 = 0 ;
37910 PyObject * obj1 = 0 ;
37911 PyObject * obj2 = 0 ;
37912 char *kwnames[] = {
37913 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37914 };
37915
37916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37918 if (SWIG_arg_fail(1)) SWIG_fail;
37919 {
37920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37921 if (SWIG_arg_fail(2)) SWIG_fail;
37922 if (arg2 == NULL) {
37923 SWIG_null_ref("wxBitmap");
37924 }
37925 if (SWIG_arg_fail(2)) SWIG_fail;
37926 }
37927 if (obj2) {
37928 {
37929 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37930 if (SWIG_arg_fail(3)) SWIG_fail;
37931 if (arg3 == NULL) {
37932 SWIG_null_ref("wxBitmap");
37933 }
37934 if (SWIG_arg_fail(3)) SWIG_fail;
37935 }
37936 }
37937 {
37938 PyThreadState* __tstate = wxPyBeginAllowThreads();
37939 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37940
37941 wxPyEndAllowThreads(__tstate);
37942 if (PyErr_Occurred()) SWIG_fail;
37943 }
37944 Py_INCREF(Py_None); resultobj = Py_None;
37945 return resultobj;
37946 fail:
37947 return NULL;
37948 }
37949
37950
37951 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37952 PyObject *resultobj = NULL;
37953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37954 wxBitmap *arg2 = 0 ;
37955 PyObject * obj0 = 0 ;
37956 PyObject * obj1 = 0 ;
37957 char *kwnames[] = {
37958 (char *) "self",(char *) "bmpDisabled", NULL
37959 };
37960
37961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37963 if (SWIG_arg_fail(1)) SWIG_fail;
37964 {
37965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37966 if (SWIG_arg_fail(2)) SWIG_fail;
37967 if (arg2 == NULL) {
37968 SWIG_null_ref("wxBitmap");
37969 }
37970 if (SWIG_arg_fail(2)) SWIG_fail;
37971 }
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37975
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 Py_INCREF(Py_None); resultobj = Py_None;
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37987 PyObject *resultobj = NULL;
37988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37989 wxBitmap *result;
37990 PyObject * obj0 = 0 ;
37991 char *kwnames[] = {
37992 (char *) "self", NULL
37993 };
37994
37995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37997 if (SWIG_arg_fail(1)) SWIG_fail;
37998 {
37999 PyThreadState* __tstate = wxPyBeginAllowThreads();
38000 {
38001 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
38002 result = (wxBitmap *) &_result_ref;
38003 }
38004
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 {
38009 wxBitmap* resultptr = new wxBitmap(*result);
38010 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38011 }
38012 return resultobj;
38013 fail:
38014 return NULL;
38015 }
38016
38017
38018 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38019 PyObject *resultobj = NULL;
38020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38021 int arg2 ;
38022 PyObject * obj0 = 0 ;
38023 PyObject * obj1 = 0 ;
38024 char *kwnames[] = {
38025 (char *) "self",(char *) "nWidth", NULL
38026 };
38027
38028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38030 if (SWIG_arg_fail(1)) SWIG_fail;
38031 {
38032 arg2 = static_cast<int >(SWIG_As_int(obj1));
38033 if (SWIG_arg_fail(2)) SWIG_fail;
38034 }
38035 {
38036 PyThreadState* __tstate = wxPyBeginAllowThreads();
38037 (arg1)->SetMarginWidth(arg2);
38038
38039 wxPyEndAllowThreads(__tstate);
38040 if (PyErr_Occurred()) SWIG_fail;
38041 }
38042 Py_INCREF(Py_None); resultobj = Py_None;
38043 return resultobj;
38044 fail:
38045 return NULL;
38046 }
38047
38048
38049 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38050 PyObject *resultobj = NULL;
38051 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38052 int result;
38053 PyObject * obj0 = 0 ;
38054 char *kwnames[] = {
38055 (char *) "self", NULL
38056 };
38057
38058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38060 if (SWIG_arg_fail(1)) SWIG_fail;
38061 {
38062 PyThreadState* __tstate = wxPyBeginAllowThreads();
38063 result = (int)(arg1)->GetMarginWidth();
38064
38065 wxPyEndAllowThreads(__tstate);
38066 if (PyErr_Occurred()) SWIG_fail;
38067 }
38068 {
38069 resultobj = SWIG_From_int(static_cast<int >(result));
38070 }
38071 return resultobj;
38072 fail:
38073 return NULL;
38074 }
38075
38076
38077 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38078 PyObject *resultobj = NULL;
38079 int result;
38080 char *kwnames[] = {
38081 NULL
38082 };
38083
38084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38085 {
38086 PyThreadState* __tstate = wxPyBeginAllowThreads();
38087 result = (int)wxMenuItem::GetDefaultMarginWidth();
38088
38089 wxPyEndAllowThreads(__tstate);
38090 if (PyErr_Occurred()) SWIG_fail;
38091 }
38092 {
38093 resultobj = SWIG_From_int(static_cast<int >(result));
38094 }
38095 return resultobj;
38096 fail:
38097 return NULL;
38098 }
38099
38100
38101 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38102 PyObject *resultobj = NULL;
38103 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38104 bool result;
38105 PyObject * obj0 = 0 ;
38106 char *kwnames[] = {
38107 (char *) "self", NULL
38108 };
38109
38110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38112 if (SWIG_arg_fail(1)) SWIG_fail;
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 result = (bool)(arg1)->IsOwnerDrawn();
38116
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 {
38121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38122 }
38123 return resultobj;
38124 fail:
38125 return NULL;
38126 }
38127
38128
38129 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38130 PyObject *resultobj = NULL;
38131 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38132 bool arg2 = (bool) true ;
38133 PyObject * obj0 = 0 ;
38134 PyObject * obj1 = 0 ;
38135 char *kwnames[] = {
38136 (char *) "self",(char *) "ownerDrawn", NULL
38137 };
38138
38139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38141 if (SWIG_arg_fail(1)) SWIG_fail;
38142 if (obj1) {
38143 {
38144 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38145 if (SWIG_arg_fail(2)) SWIG_fail;
38146 }
38147 }
38148 {
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 (arg1)->SetOwnerDrawn(arg2);
38151
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 Py_INCREF(Py_None); resultobj = Py_None;
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38163 PyObject *resultobj = NULL;
38164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38165 PyObject * obj0 = 0 ;
38166 char *kwnames[] = {
38167 (char *) "self", NULL
38168 };
38169
38170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38172 if (SWIG_arg_fail(1)) SWIG_fail;
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 (arg1)->ResetOwnerDrawn();
38176
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 Py_INCREF(Py_None); resultobj = Py_None;
38181 return resultobj;
38182 fail:
38183 return NULL;
38184 }
38185
38186
38187 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38188 PyObject *obj;
38189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38190 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38191 Py_INCREF(obj);
38192 return Py_BuildValue((char *)"");
38193 }
38194 static int _wrap_ControlNameStr_set(PyObject *) {
38195 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38196 return 1;
38197 }
38198
38199
38200 static PyObject *_wrap_ControlNameStr_get(void) {
38201 PyObject *pyobj = NULL;
38202
38203 {
38204 #if wxUSE_UNICODE
38205 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38206 #else
38207 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38208 #endif
38209 }
38210 return pyobj;
38211 }
38212
38213
38214 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj = NULL;
38216 wxWindow *arg1 = (wxWindow *) 0 ;
38217 int arg2 = (int) -1 ;
38218 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38219 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38220 wxSize const &arg4_defvalue = wxDefaultSize ;
38221 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38222 long arg5 = (long) 0 ;
38223 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38224 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38225 wxString const &arg7_defvalue = wxPyControlNameStr ;
38226 wxString *arg7 = (wxString *) &arg7_defvalue ;
38227 wxControl *result;
38228 wxPoint temp3 ;
38229 wxSize temp4 ;
38230 bool temp7 = false ;
38231 PyObject * obj0 = 0 ;
38232 PyObject * obj1 = 0 ;
38233 PyObject * obj2 = 0 ;
38234 PyObject * obj3 = 0 ;
38235 PyObject * obj4 = 0 ;
38236 PyObject * obj5 = 0 ;
38237 PyObject * obj6 = 0 ;
38238 char *kwnames[] = {
38239 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38240 };
38241
38242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38244 if (SWIG_arg_fail(1)) SWIG_fail;
38245 if (obj1) {
38246 {
38247 arg2 = static_cast<int >(SWIG_As_int(obj1));
38248 if (SWIG_arg_fail(2)) SWIG_fail;
38249 }
38250 }
38251 if (obj2) {
38252 {
38253 arg3 = &temp3;
38254 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38255 }
38256 }
38257 if (obj3) {
38258 {
38259 arg4 = &temp4;
38260 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38261 }
38262 }
38263 if (obj4) {
38264 {
38265 arg5 = static_cast<long >(SWIG_As_long(obj4));
38266 if (SWIG_arg_fail(5)) SWIG_fail;
38267 }
38268 }
38269 if (obj5) {
38270 {
38271 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38272 if (SWIG_arg_fail(6)) SWIG_fail;
38273 if (arg6 == NULL) {
38274 SWIG_null_ref("wxValidator");
38275 }
38276 if (SWIG_arg_fail(6)) SWIG_fail;
38277 }
38278 }
38279 if (obj6) {
38280 {
38281 arg7 = wxString_in_helper(obj6);
38282 if (arg7 == NULL) SWIG_fail;
38283 temp7 = true;
38284 }
38285 }
38286 {
38287 if (!wxPyCheckForApp()) SWIG_fail;
38288 PyThreadState* __tstate = wxPyBeginAllowThreads();
38289 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38290
38291 wxPyEndAllowThreads(__tstate);
38292 if (PyErr_Occurred()) SWIG_fail;
38293 }
38294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38295 {
38296 if (temp7)
38297 delete arg7;
38298 }
38299 return resultobj;
38300 fail:
38301 {
38302 if (temp7)
38303 delete arg7;
38304 }
38305 return NULL;
38306 }
38307
38308
38309 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38310 PyObject *resultobj = NULL;
38311 wxControl *result;
38312 char *kwnames[] = {
38313 NULL
38314 };
38315
38316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38317 {
38318 if (!wxPyCheckForApp()) SWIG_fail;
38319 PyThreadState* __tstate = wxPyBeginAllowThreads();
38320 result = (wxControl *)new wxControl();
38321
38322 wxPyEndAllowThreads(__tstate);
38323 if (PyErr_Occurred()) SWIG_fail;
38324 }
38325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38326 return resultobj;
38327 fail:
38328 return NULL;
38329 }
38330
38331
38332 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38333 PyObject *resultobj = NULL;
38334 wxControl *arg1 = (wxControl *) 0 ;
38335 wxWindow *arg2 = (wxWindow *) 0 ;
38336 int arg3 = (int) -1 ;
38337 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38338 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38339 wxSize const &arg5_defvalue = wxDefaultSize ;
38340 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38341 long arg6 = (long) 0 ;
38342 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38343 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38344 wxString const &arg8_defvalue = wxPyControlNameStr ;
38345 wxString *arg8 = (wxString *) &arg8_defvalue ;
38346 bool result;
38347 wxPoint temp4 ;
38348 wxSize temp5 ;
38349 bool temp8 = false ;
38350 PyObject * obj0 = 0 ;
38351 PyObject * obj1 = 0 ;
38352 PyObject * obj2 = 0 ;
38353 PyObject * obj3 = 0 ;
38354 PyObject * obj4 = 0 ;
38355 PyObject * obj5 = 0 ;
38356 PyObject * obj6 = 0 ;
38357 PyObject * obj7 = 0 ;
38358 char *kwnames[] = {
38359 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38360 };
38361
38362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38364 if (SWIG_arg_fail(1)) SWIG_fail;
38365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38366 if (SWIG_arg_fail(2)) SWIG_fail;
38367 if (obj2) {
38368 {
38369 arg3 = static_cast<int >(SWIG_As_int(obj2));
38370 if (SWIG_arg_fail(3)) SWIG_fail;
38371 }
38372 }
38373 if (obj3) {
38374 {
38375 arg4 = &temp4;
38376 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38377 }
38378 }
38379 if (obj4) {
38380 {
38381 arg5 = &temp5;
38382 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38383 }
38384 }
38385 if (obj5) {
38386 {
38387 arg6 = static_cast<long >(SWIG_As_long(obj5));
38388 if (SWIG_arg_fail(6)) SWIG_fail;
38389 }
38390 }
38391 if (obj6) {
38392 {
38393 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38394 if (SWIG_arg_fail(7)) SWIG_fail;
38395 if (arg7 == NULL) {
38396 SWIG_null_ref("wxValidator");
38397 }
38398 if (SWIG_arg_fail(7)) SWIG_fail;
38399 }
38400 }
38401 if (obj7) {
38402 {
38403 arg8 = wxString_in_helper(obj7);
38404 if (arg8 == NULL) SWIG_fail;
38405 temp8 = true;
38406 }
38407 }
38408 {
38409 PyThreadState* __tstate = wxPyBeginAllowThreads();
38410 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38411
38412 wxPyEndAllowThreads(__tstate);
38413 if (PyErr_Occurred()) SWIG_fail;
38414 }
38415 {
38416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38417 }
38418 {
38419 if (temp8)
38420 delete arg8;
38421 }
38422 return resultobj;
38423 fail:
38424 {
38425 if (temp8)
38426 delete arg8;
38427 }
38428 return NULL;
38429 }
38430
38431
38432 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38433 PyObject *resultobj = NULL;
38434 wxControl *arg1 = (wxControl *) 0 ;
38435 wxCommandEvent *arg2 = 0 ;
38436 PyObject * obj0 = 0 ;
38437 PyObject * obj1 = 0 ;
38438 char *kwnames[] = {
38439 (char *) "self",(char *) "event", NULL
38440 };
38441
38442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38444 if (SWIG_arg_fail(1)) SWIG_fail;
38445 {
38446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38447 if (SWIG_arg_fail(2)) SWIG_fail;
38448 if (arg2 == NULL) {
38449 SWIG_null_ref("wxCommandEvent");
38450 }
38451 if (SWIG_arg_fail(2)) SWIG_fail;
38452 }
38453 {
38454 PyThreadState* __tstate = wxPyBeginAllowThreads();
38455 (arg1)->Command(*arg2);
38456
38457 wxPyEndAllowThreads(__tstate);
38458 if (PyErr_Occurred()) SWIG_fail;
38459 }
38460 Py_INCREF(Py_None); resultobj = Py_None;
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38468 PyObject *resultobj = NULL;
38469 wxControl *arg1 = (wxControl *) 0 ;
38470 wxString result;
38471 PyObject * obj0 = 0 ;
38472 char *kwnames[] = {
38473 (char *) "self", NULL
38474 };
38475
38476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38478 if (SWIG_arg_fail(1)) SWIG_fail;
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 result = (arg1)->GetLabel();
38482
38483 wxPyEndAllowThreads(__tstate);
38484 if (PyErr_Occurred()) SWIG_fail;
38485 }
38486 {
38487 #if wxUSE_UNICODE
38488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38489 #else
38490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38491 #endif
38492 }
38493 return resultobj;
38494 fail:
38495 return NULL;
38496 }
38497
38498
38499 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38500 PyObject *resultobj = NULL;
38501 wxControl *arg1 = (wxControl *) 0 ;
38502 wxString *arg2 = 0 ;
38503 bool temp2 = false ;
38504 PyObject * obj0 = 0 ;
38505 PyObject * obj1 = 0 ;
38506 char *kwnames[] = {
38507 (char *) "self",(char *) "label", NULL
38508 };
38509
38510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38512 if (SWIG_arg_fail(1)) SWIG_fail;
38513 {
38514 arg2 = wxString_in_helper(obj1);
38515 if (arg2 == NULL) SWIG_fail;
38516 temp2 = true;
38517 }
38518 {
38519 PyThreadState* __tstate = wxPyBeginAllowThreads();
38520 (arg1)->SetLabel((wxString const &)*arg2);
38521
38522 wxPyEndAllowThreads(__tstate);
38523 if (PyErr_Occurred()) SWIG_fail;
38524 }
38525 Py_INCREF(Py_None); resultobj = Py_None;
38526 {
38527 if (temp2)
38528 delete arg2;
38529 }
38530 return resultobj;
38531 fail:
38532 {
38533 if (temp2)
38534 delete arg2;
38535 }
38536 return NULL;
38537 }
38538
38539
38540 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj = NULL;
38542 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38543 wxVisualAttributes result;
38544 PyObject * obj0 = 0 ;
38545 char *kwnames[] = {
38546 (char *) "variant", NULL
38547 };
38548
38549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38550 if (obj0) {
38551 {
38552 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38553 if (SWIG_arg_fail(1)) SWIG_fail;
38554 }
38555 }
38556 {
38557 if (!wxPyCheckForApp()) SWIG_fail;
38558 PyThreadState* __tstate = wxPyBeginAllowThreads();
38559 result = wxControl::GetClassDefaultAttributes(arg1);
38560
38561 wxPyEndAllowThreads(__tstate);
38562 if (PyErr_Occurred()) SWIG_fail;
38563 }
38564 {
38565 wxVisualAttributes * resultptr;
38566 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38568 }
38569 return resultobj;
38570 fail:
38571 return NULL;
38572 }
38573
38574
38575 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38576 PyObject *obj;
38577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38578 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38579 Py_INCREF(obj);
38580 return Py_BuildValue((char *)"");
38581 }
38582 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38583 PyObject *resultobj = NULL;
38584 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38585 wxString *arg2 = 0 ;
38586 PyObject *arg3 = (PyObject *) NULL ;
38587 int result;
38588 bool temp2 = false ;
38589 PyObject * obj0 = 0 ;
38590 PyObject * obj1 = 0 ;
38591 PyObject * obj2 = 0 ;
38592 char *kwnames[] = {
38593 (char *) "self",(char *) "item",(char *) "clientData", NULL
38594 };
38595
38596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38598 if (SWIG_arg_fail(1)) SWIG_fail;
38599 {
38600 arg2 = wxString_in_helper(obj1);
38601 if (arg2 == NULL) SWIG_fail;
38602 temp2 = true;
38603 }
38604 if (obj2) {
38605 arg3 = obj2;
38606 }
38607 {
38608 PyThreadState* __tstate = wxPyBeginAllowThreads();
38609 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38610
38611 wxPyEndAllowThreads(__tstate);
38612 if (PyErr_Occurred()) SWIG_fail;
38613 }
38614 {
38615 resultobj = SWIG_From_int(static_cast<int >(result));
38616 }
38617 {
38618 if (temp2)
38619 delete arg2;
38620 }
38621 return resultobj;
38622 fail:
38623 {
38624 if (temp2)
38625 delete arg2;
38626 }
38627 return NULL;
38628 }
38629
38630
38631 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38632 PyObject *resultobj = NULL;
38633 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38634 wxArrayString *arg2 = 0 ;
38635 bool temp2 = false ;
38636 PyObject * obj0 = 0 ;
38637 PyObject * obj1 = 0 ;
38638 char *kwnames[] = {
38639 (char *) "self",(char *) "strings", NULL
38640 };
38641
38642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38644 if (SWIG_arg_fail(1)) SWIG_fail;
38645 {
38646 if (! PySequence_Check(obj1)) {
38647 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38648 SWIG_fail;
38649 }
38650 arg2 = new wxArrayString;
38651 temp2 = true;
38652 int i, len=PySequence_Length(obj1);
38653 for (i=0; i<len; i++) {
38654 PyObject* item = PySequence_GetItem(obj1, i);
38655 wxString* s = wxString_in_helper(item);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 arg2->Add(*s);
38658 delete s;
38659 Py_DECREF(item);
38660 }
38661 }
38662 {
38663 PyThreadState* __tstate = wxPyBeginAllowThreads();
38664 (arg1)->Append((wxArrayString const &)*arg2);
38665
38666 wxPyEndAllowThreads(__tstate);
38667 if (PyErr_Occurred()) SWIG_fail;
38668 }
38669 Py_INCREF(Py_None); resultobj = Py_None;
38670 {
38671 if (temp2) delete arg2;
38672 }
38673 return resultobj;
38674 fail:
38675 {
38676 if (temp2) delete arg2;
38677 }
38678 return NULL;
38679 }
38680
38681
38682 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38683 PyObject *resultobj = NULL;
38684 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38685 wxString *arg2 = 0 ;
38686 int arg3 ;
38687 PyObject *arg4 = (PyObject *) NULL ;
38688 int result;
38689 bool temp2 = false ;
38690 PyObject * obj0 = 0 ;
38691 PyObject * obj1 = 0 ;
38692 PyObject * obj2 = 0 ;
38693 PyObject * obj3 = 0 ;
38694 char *kwnames[] = {
38695 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38696 };
38697
38698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38700 if (SWIG_arg_fail(1)) SWIG_fail;
38701 {
38702 arg2 = wxString_in_helper(obj1);
38703 if (arg2 == NULL) SWIG_fail;
38704 temp2 = true;
38705 }
38706 {
38707 arg3 = static_cast<int >(SWIG_As_int(obj2));
38708 if (SWIG_arg_fail(3)) SWIG_fail;
38709 }
38710 if (obj3) {
38711 arg4 = obj3;
38712 }
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38716
38717 wxPyEndAllowThreads(__tstate);
38718 if (PyErr_Occurred()) SWIG_fail;
38719 }
38720 {
38721 resultobj = SWIG_From_int(static_cast<int >(result));
38722 }
38723 {
38724 if (temp2)
38725 delete arg2;
38726 }
38727 return resultobj;
38728 fail:
38729 {
38730 if (temp2)
38731 delete arg2;
38732 }
38733 return NULL;
38734 }
38735
38736
38737 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38738 PyObject *resultobj = NULL;
38739 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38740 PyObject * obj0 = 0 ;
38741 char *kwnames[] = {
38742 (char *) "self", NULL
38743 };
38744
38745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38747 if (SWIG_arg_fail(1)) SWIG_fail;
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 (arg1)->Clear();
38751
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 Py_INCREF(Py_None); resultobj = Py_None;
38756 return resultobj;
38757 fail:
38758 return NULL;
38759 }
38760
38761
38762 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38763 PyObject *resultobj = NULL;
38764 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38765 int arg2 ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 char *kwnames[] = {
38769 (char *) "self",(char *) "n", NULL
38770 };
38771
38772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38774 if (SWIG_arg_fail(1)) SWIG_fail;
38775 {
38776 arg2 = static_cast<int >(SWIG_As_int(obj1));
38777 if (SWIG_arg_fail(2)) SWIG_fail;
38778 }
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 (arg1)->Delete(arg2);
38782
38783 wxPyEndAllowThreads(__tstate);
38784 if (PyErr_Occurred()) SWIG_fail;
38785 }
38786 Py_INCREF(Py_None); resultobj = Py_None;
38787 return resultobj;
38788 fail:
38789 return NULL;
38790 }
38791
38792
38793 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38794 PyObject *resultobj = NULL;
38795 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38796 int arg2 ;
38797 PyObject *result;
38798 PyObject * obj0 = 0 ;
38799 PyObject * obj1 = 0 ;
38800 char *kwnames[] = {
38801 (char *) "self",(char *) "n", NULL
38802 };
38803
38804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38806 if (SWIG_arg_fail(1)) SWIG_fail;
38807 {
38808 arg2 = static_cast<int >(SWIG_As_int(obj1));
38809 if (SWIG_arg_fail(2)) SWIG_fail;
38810 }
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38814
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 resultobj = result;
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38826 PyObject *resultobj = NULL;
38827 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38828 int arg2 ;
38829 PyObject *arg3 = (PyObject *) 0 ;
38830 PyObject * obj0 = 0 ;
38831 PyObject * obj1 = 0 ;
38832 PyObject * obj2 = 0 ;
38833 char *kwnames[] = {
38834 (char *) "self",(char *) "n",(char *) "clientData", NULL
38835 };
38836
38837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38839 if (SWIG_arg_fail(1)) SWIG_fail;
38840 {
38841 arg2 = static_cast<int >(SWIG_As_int(obj1));
38842 if (SWIG_arg_fail(2)) SWIG_fail;
38843 }
38844 arg3 = obj2;
38845 {
38846 PyThreadState* __tstate = wxPyBeginAllowThreads();
38847 wxItemContainer_SetClientData(arg1,arg2,arg3);
38848
38849 wxPyEndAllowThreads(__tstate);
38850 if (PyErr_Occurred()) SWIG_fail;
38851 }
38852 Py_INCREF(Py_None); resultobj = Py_None;
38853 return resultobj;
38854 fail:
38855 return NULL;
38856 }
38857
38858
38859 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38860 PyObject *resultobj = NULL;
38861 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38862 int result;
38863 PyObject * obj0 = 0 ;
38864 char *kwnames[] = {
38865 (char *) "self", NULL
38866 };
38867
38868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38870 if (SWIG_arg_fail(1)) SWIG_fail;
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 result = (int)((wxItemContainer const *)arg1)->GetCount();
38874
38875 wxPyEndAllowThreads(__tstate);
38876 if (PyErr_Occurred()) SWIG_fail;
38877 }
38878 {
38879 resultobj = SWIG_From_int(static_cast<int >(result));
38880 }
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38888 PyObject *resultobj = NULL;
38889 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38890 bool result;
38891 PyObject * obj0 = 0 ;
38892 char *kwnames[] = {
38893 (char *) "self", NULL
38894 };
38895
38896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38898 if (SWIG_arg_fail(1)) SWIG_fail;
38899 {
38900 PyThreadState* __tstate = wxPyBeginAllowThreads();
38901 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38902
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 {
38907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38908 }
38909 return resultobj;
38910 fail:
38911 return NULL;
38912 }
38913
38914
38915 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38916 PyObject *resultobj = NULL;
38917 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38918 int arg2 ;
38919 wxString result;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 char *kwnames[] = {
38923 (char *) "self",(char *) "n", NULL
38924 };
38925
38926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38928 if (SWIG_arg_fail(1)) SWIG_fail;
38929 {
38930 arg2 = static_cast<int >(SWIG_As_int(obj1));
38931 if (SWIG_arg_fail(2)) SWIG_fail;
38932 }
38933 {
38934 PyThreadState* __tstate = wxPyBeginAllowThreads();
38935 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38936
38937 wxPyEndAllowThreads(__tstate);
38938 if (PyErr_Occurred()) SWIG_fail;
38939 }
38940 {
38941 #if wxUSE_UNICODE
38942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38943 #else
38944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38945 #endif
38946 }
38947 return resultobj;
38948 fail:
38949 return NULL;
38950 }
38951
38952
38953 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38954 PyObject *resultobj = NULL;
38955 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38956 wxArrayString result;
38957 PyObject * obj0 = 0 ;
38958 char *kwnames[] = {
38959 (char *) "self", NULL
38960 };
38961
38962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38964 if (SWIG_arg_fail(1)) SWIG_fail;
38965 {
38966 PyThreadState* __tstate = wxPyBeginAllowThreads();
38967 result = ((wxItemContainer const *)arg1)->GetStrings();
38968
38969 wxPyEndAllowThreads(__tstate);
38970 if (PyErr_Occurred()) SWIG_fail;
38971 }
38972 {
38973 resultobj = wxArrayString2PyList_helper(result);
38974 }
38975 return resultobj;
38976 fail:
38977 return NULL;
38978 }
38979
38980
38981 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38982 PyObject *resultobj = NULL;
38983 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38984 int arg2 ;
38985 wxString *arg3 = 0 ;
38986 bool temp3 = false ;
38987 PyObject * obj0 = 0 ;
38988 PyObject * obj1 = 0 ;
38989 PyObject * obj2 = 0 ;
38990 char *kwnames[] = {
38991 (char *) "self",(char *) "n",(char *) "s", NULL
38992 };
38993
38994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38996 if (SWIG_arg_fail(1)) SWIG_fail;
38997 {
38998 arg2 = static_cast<int >(SWIG_As_int(obj1));
38999 if (SWIG_arg_fail(2)) SWIG_fail;
39000 }
39001 {
39002 arg3 = wxString_in_helper(obj2);
39003 if (arg3 == NULL) SWIG_fail;
39004 temp3 = true;
39005 }
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 (arg1)->SetString(arg2,(wxString const &)*arg3);
39009
39010 wxPyEndAllowThreads(__tstate);
39011 if (PyErr_Occurred()) SWIG_fail;
39012 }
39013 Py_INCREF(Py_None); resultobj = Py_None;
39014 {
39015 if (temp3)
39016 delete arg3;
39017 }
39018 return resultobj;
39019 fail:
39020 {
39021 if (temp3)
39022 delete arg3;
39023 }
39024 return NULL;
39025 }
39026
39027
39028 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj = NULL;
39030 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39031 wxString *arg2 = 0 ;
39032 int result;
39033 bool temp2 = false ;
39034 PyObject * obj0 = 0 ;
39035 PyObject * obj1 = 0 ;
39036 char *kwnames[] = {
39037 (char *) "self",(char *) "s", NULL
39038 };
39039
39040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39042 if (SWIG_arg_fail(1)) SWIG_fail;
39043 {
39044 arg2 = wxString_in_helper(obj1);
39045 if (arg2 == NULL) SWIG_fail;
39046 temp2 = true;
39047 }
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39051
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 {
39056 resultobj = SWIG_From_int(static_cast<int >(result));
39057 }
39058 {
39059 if (temp2)
39060 delete arg2;
39061 }
39062 return resultobj;
39063 fail:
39064 {
39065 if (temp2)
39066 delete arg2;
39067 }
39068 return NULL;
39069 }
39070
39071
39072 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39073 PyObject *resultobj = NULL;
39074 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39075 int arg2 ;
39076 PyObject * obj0 = 0 ;
39077 PyObject * obj1 = 0 ;
39078 char *kwnames[] = {
39079 (char *) "self",(char *) "n", NULL
39080 };
39081
39082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39084 if (SWIG_arg_fail(1)) SWIG_fail;
39085 {
39086 arg2 = static_cast<int >(SWIG_As_int(obj1));
39087 if (SWIG_arg_fail(2)) SWIG_fail;
39088 }
39089 {
39090 PyThreadState* __tstate = wxPyBeginAllowThreads();
39091 (arg1)->SetSelection(arg2);
39092
39093 wxPyEndAllowThreads(__tstate);
39094 if (PyErr_Occurred()) SWIG_fail;
39095 }
39096 Py_INCREF(Py_None); resultobj = Py_None;
39097 return resultobj;
39098 fail:
39099 return NULL;
39100 }
39101
39102
39103 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39104 PyObject *resultobj = NULL;
39105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39106 int result;
39107 PyObject * obj0 = 0 ;
39108 char *kwnames[] = {
39109 (char *) "self", NULL
39110 };
39111
39112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39114 if (SWIG_arg_fail(1)) SWIG_fail;
39115 {
39116 PyThreadState* __tstate = wxPyBeginAllowThreads();
39117 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39118
39119 wxPyEndAllowThreads(__tstate);
39120 if (PyErr_Occurred()) SWIG_fail;
39121 }
39122 {
39123 resultobj = SWIG_From_int(static_cast<int >(result));
39124 }
39125 return resultobj;
39126 fail:
39127 return NULL;
39128 }
39129
39130
39131 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39132 PyObject *resultobj = NULL;
39133 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39134 wxString *arg2 = 0 ;
39135 bool result;
39136 bool temp2 = false ;
39137 PyObject * obj0 = 0 ;
39138 PyObject * obj1 = 0 ;
39139 char *kwnames[] = {
39140 (char *) "self",(char *) "s", NULL
39141 };
39142
39143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39145 if (SWIG_arg_fail(1)) SWIG_fail;
39146 {
39147 arg2 = wxString_in_helper(obj1);
39148 if (arg2 == NULL) SWIG_fail;
39149 temp2 = true;
39150 }
39151 {
39152 PyThreadState* __tstate = wxPyBeginAllowThreads();
39153 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39154
39155 wxPyEndAllowThreads(__tstate);
39156 if (PyErr_Occurred()) SWIG_fail;
39157 }
39158 {
39159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39160 }
39161 {
39162 if (temp2)
39163 delete arg2;
39164 }
39165 return resultobj;
39166 fail:
39167 {
39168 if (temp2)
39169 delete arg2;
39170 }
39171 return NULL;
39172 }
39173
39174
39175 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj = NULL;
39177 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39178 wxString result;
39179 PyObject * obj0 = 0 ;
39180 char *kwnames[] = {
39181 (char *) "self", NULL
39182 };
39183
39184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39186 if (SWIG_arg_fail(1)) SWIG_fail;
39187 {
39188 PyThreadState* __tstate = wxPyBeginAllowThreads();
39189 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39190
39191 wxPyEndAllowThreads(__tstate);
39192 if (PyErr_Occurred()) SWIG_fail;
39193 }
39194 {
39195 #if wxUSE_UNICODE
39196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39197 #else
39198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39199 #endif
39200 }
39201 return resultobj;
39202 fail:
39203 return NULL;
39204 }
39205
39206
39207 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39208 PyObject *resultobj = NULL;
39209 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39210 int arg2 ;
39211 PyObject * obj0 = 0 ;
39212 PyObject * obj1 = 0 ;
39213 char *kwnames[] = {
39214 (char *) "self",(char *) "n", NULL
39215 };
39216
39217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39219 if (SWIG_arg_fail(1)) SWIG_fail;
39220 {
39221 arg2 = static_cast<int >(SWIG_As_int(obj1));
39222 if (SWIG_arg_fail(2)) SWIG_fail;
39223 }
39224 {
39225 PyThreadState* __tstate = wxPyBeginAllowThreads();
39226 (arg1)->Select(arg2);
39227
39228 wxPyEndAllowThreads(__tstate);
39229 if (PyErr_Occurred()) SWIG_fail;
39230 }
39231 Py_INCREF(Py_None); resultobj = Py_None;
39232 return resultobj;
39233 fail:
39234 return NULL;
39235 }
39236
39237
39238 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39239 PyObject *obj;
39240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39241 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39242 Py_INCREF(obj);
39243 return Py_BuildValue((char *)"");
39244 }
39245 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39246 PyObject *obj;
39247 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39248 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39249 Py_INCREF(obj);
39250 return Py_BuildValue((char *)"");
39251 }
39252 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39253 PyObject *resultobj = NULL;
39254 wxSizerItem *result;
39255 char *kwnames[] = {
39256 NULL
39257 };
39258
39259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39260 {
39261 PyThreadState* __tstate = wxPyBeginAllowThreads();
39262 result = (wxSizerItem *)new wxSizerItem();
39263
39264 wxPyEndAllowThreads(__tstate);
39265 if (PyErr_Occurred()) SWIG_fail;
39266 }
39267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39268 return resultobj;
39269 fail:
39270 return NULL;
39271 }
39272
39273
39274 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39275 PyObject *resultobj = NULL;
39276 wxWindow *arg1 = (wxWindow *) 0 ;
39277 int arg2 ;
39278 int arg3 ;
39279 int arg4 ;
39280 PyObject *arg5 = (PyObject *) NULL ;
39281 wxSizerItem *result;
39282 PyObject * obj0 = 0 ;
39283 PyObject * obj1 = 0 ;
39284 PyObject * obj2 = 0 ;
39285 PyObject * obj3 = 0 ;
39286 PyObject * obj4 = 0 ;
39287 char *kwnames[] = {
39288 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39289 };
39290
39291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39293 if (SWIG_arg_fail(1)) SWIG_fail;
39294 {
39295 arg2 = static_cast<int >(SWIG_As_int(obj1));
39296 if (SWIG_arg_fail(2)) SWIG_fail;
39297 }
39298 {
39299 arg3 = static_cast<int >(SWIG_As_int(obj2));
39300 if (SWIG_arg_fail(3)) SWIG_fail;
39301 }
39302 {
39303 arg4 = static_cast<int >(SWIG_As_int(obj3));
39304 if (SWIG_arg_fail(4)) SWIG_fail;
39305 }
39306 if (obj4) {
39307 arg5 = obj4;
39308 }
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39312
39313 wxPyEndAllowThreads(__tstate);
39314 if (PyErr_Occurred()) SWIG_fail;
39315 }
39316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39324 PyObject *resultobj = NULL;
39325 int arg1 ;
39326 int arg2 ;
39327 int arg3 ;
39328 int arg4 ;
39329 int arg5 ;
39330 PyObject *arg6 = (PyObject *) NULL ;
39331 wxSizerItem *result;
39332 PyObject * obj0 = 0 ;
39333 PyObject * obj1 = 0 ;
39334 PyObject * obj2 = 0 ;
39335 PyObject * obj3 = 0 ;
39336 PyObject * obj4 = 0 ;
39337 PyObject * obj5 = 0 ;
39338 char *kwnames[] = {
39339 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39340 };
39341
39342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39343 {
39344 arg1 = static_cast<int >(SWIG_As_int(obj0));
39345 if (SWIG_arg_fail(1)) SWIG_fail;
39346 }
39347 {
39348 arg2 = static_cast<int >(SWIG_As_int(obj1));
39349 if (SWIG_arg_fail(2)) SWIG_fail;
39350 }
39351 {
39352 arg3 = static_cast<int >(SWIG_As_int(obj2));
39353 if (SWIG_arg_fail(3)) SWIG_fail;
39354 }
39355 {
39356 arg4 = static_cast<int >(SWIG_As_int(obj3));
39357 if (SWIG_arg_fail(4)) SWIG_fail;
39358 }
39359 {
39360 arg5 = static_cast<int >(SWIG_As_int(obj4));
39361 if (SWIG_arg_fail(5)) SWIG_fail;
39362 }
39363 if (obj5) {
39364 arg6 = obj5;
39365 }
39366 {
39367 PyThreadState* __tstate = wxPyBeginAllowThreads();
39368 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39369
39370 wxPyEndAllowThreads(__tstate);
39371 if (PyErr_Occurred()) SWIG_fail;
39372 }
39373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39374 return resultobj;
39375 fail:
39376 return NULL;
39377 }
39378
39379
39380 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39381 PyObject *resultobj = NULL;
39382 wxSizer *arg1 = (wxSizer *) 0 ;
39383 int arg2 ;
39384 int arg3 ;
39385 int arg4 ;
39386 PyObject *arg5 = (PyObject *) NULL ;
39387 wxSizerItem *result;
39388 PyObject * obj0 = 0 ;
39389 PyObject * obj1 = 0 ;
39390 PyObject * obj2 = 0 ;
39391 PyObject * obj3 = 0 ;
39392 PyObject * obj4 = 0 ;
39393 char *kwnames[] = {
39394 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39395 };
39396
39397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39399 if (SWIG_arg_fail(1)) SWIG_fail;
39400 {
39401 arg2 = static_cast<int >(SWIG_As_int(obj1));
39402 if (SWIG_arg_fail(2)) SWIG_fail;
39403 }
39404 {
39405 arg3 = static_cast<int >(SWIG_As_int(obj2));
39406 if (SWIG_arg_fail(3)) SWIG_fail;
39407 }
39408 {
39409 arg4 = static_cast<int >(SWIG_As_int(obj3));
39410 if (SWIG_arg_fail(4)) SWIG_fail;
39411 }
39412 if (obj4) {
39413 arg5 = obj4;
39414 }
39415 {
39416 PyThreadState* __tstate = wxPyBeginAllowThreads();
39417 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39418
39419 wxPyEndAllowThreads(__tstate);
39420 if (PyErr_Occurred()) SWIG_fail;
39421 }
39422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39423 return resultobj;
39424 fail:
39425 return NULL;
39426 }
39427
39428
39429 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39430 PyObject *resultobj = NULL;
39431 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39432 PyObject * obj0 = 0 ;
39433 char *kwnames[] = {
39434 (char *) "self", NULL
39435 };
39436
39437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39439 if (SWIG_arg_fail(1)) SWIG_fail;
39440 {
39441 PyThreadState* __tstate = wxPyBeginAllowThreads();
39442 (arg1)->DeleteWindows();
39443
39444 wxPyEndAllowThreads(__tstate);
39445 if (PyErr_Occurred()) SWIG_fail;
39446 }
39447 Py_INCREF(Py_None); resultobj = Py_None;
39448 return resultobj;
39449 fail:
39450 return NULL;
39451 }
39452
39453
39454 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39455 PyObject *resultobj = NULL;
39456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39457 PyObject * obj0 = 0 ;
39458 char *kwnames[] = {
39459 (char *) "self", NULL
39460 };
39461
39462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39464 if (SWIG_arg_fail(1)) SWIG_fail;
39465 {
39466 PyThreadState* __tstate = wxPyBeginAllowThreads();
39467 (arg1)->DetachSizer();
39468
39469 wxPyEndAllowThreads(__tstate);
39470 if (PyErr_Occurred()) SWIG_fail;
39471 }
39472 Py_INCREF(Py_None); resultobj = Py_None;
39473 return resultobj;
39474 fail:
39475 return NULL;
39476 }
39477
39478
39479 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39480 PyObject *resultobj = NULL;
39481 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39482 wxSize result;
39483 PyObject * obj0 = 0 ;
39484 char *kwnames[] = {
39485 (char *) "self", NULL
39486 };
39487
39488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39490 if (SWIG_arg_fail(1)) SWIG_fail;
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 result = (arg1)->GetSize();
39494
39495 wxPyEndAllowThreads(__tstate);
39496 if (PyErr_Occurred()) SWIG_fail;
39497 }
39498 {
39499 wxSize * resultptr;
39500 resultptr = new wxSize(static_cast<wxSize & >(result));
39501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39502 }
39503 return resultobj;
39504 fail:
39505 return NULL;
39506 }
39507
39508
39509 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39510 PyObject *resultobj = NULL;
39511 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39512 wxSize result;
39513 PyObject * obj0 = 0 ;
39514 char *kwnames[] = {
39515 (char *) "self", NULL
39516 };
39517
39518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39520 if (SWIG_arg_fail(1)) SWIG_fail;
39521 {
39522 PyThreadState* __tstate = wxPyBeginAllowThreads();
39523 result = (arg1)->CalcMin();
39524
39525 wxPyEndAllowThreads(__tstate);
39526 if (PyErr_Occurred()) SWIG_fail;
39527 }
39528 {
39529 wxSize * resultptr;
39530 resultptr = new wxSize(static_cast<wxSize & >(result));
39531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39532 }
39533 return resultobj;
39534 fail:
39535 return NULL;
39536 }
39537
39538
39539 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39540 PyObject *resultobj = NULL;
39541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39542 wxPoint arg2 ;
39543 wxSize arg3 ;
39544 PyObject * obj0 = 0 ;
39545 PyObject * obj1 = 0 ;
39546 PyObject * obj2 = 0 ;
39547 char *kwnames[] = {
39548 (char *) "self",(char *) "pos",(char *) "size", NULL
39549 };
39550
39551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39553 if (SWIG_arg_fail(1)) SWIG_fail;
39554 {
39555 wxPoint * argp;
39556 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39557 if (SWIG_arg_fail(2)) SWIG_fail;
39558 if (argp == NULL) {
39559 SWIG_null_ref("wxPoint");
39560 }
39561 if (SWIG_arg_fail(2)) SWIG_fail;
39562 arg2 = *argp;
39563 }
39564 {
39565 wxSize * argp;
39566 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39567 if (SWIG_arg_fail(3)) SWIG_fail;
39568 if (argp == NULL) {
39569 SWIG_null_ref("wxSize");
39570 }
39571 if (SWIG_arg_fail(3)) SWIG_fail;
39572 arg3 = *argp;
39573 }
39574 {
39575 PyThreadState* __tstate = wxPyBeginAllowThreads();
39576 (arg1)->SetDimension(arg2,arg3);
39577
39578 wxPyEndAllowThreads(__tstate);
39579 if (PyErr_Occurred()) SWIG_fail;
39580 }
39581 Py_INCREF(Py_None); resultobj = Py_None;
39582 return resultobj;
39583 fail:
39584 return NULL;
39585 }
39586
39587
39588 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39589 PyObject *resultobj = NULL;
39590 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39591 wxSize result;
39592 PyObject * obj0 = 0 ;
39593 char *kwnames[] = {
39594 (char *) "self", NULL
39595 };
39596
39597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39599 if (SWIG_arg_fail(1)) SWIG_fail;
39600 {
39601 PyThreadState* __tstate = wxPyBeginAllowThreads();
39602 result = (arg1)->GetMinSize();
39603
39604 wxPyEndAllowThreads(__tstate);
39605 if (PyErr_Occurred()) SWIG_fail;
39606 }
39607 {
39608 wxSize * resultptr;
39609 resultptr = new wxSize(static_cast<wxSize & >(result));
39610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39611 }
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39619 PyObject *resultobj = NULL;
39620 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39621 wxSize result;
39622 PyObject * obj0 = 0 ;
39623 char *kwnames[] = {
39624 (char *) "self", NULL
39625 };
39626
39627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39629 if (SWIG_arg_fail(1)) SWIG_fail;
39630 {
39631 PyThreadState* __tstate = wxPyBeginAllowThreads();
39632 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39633
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 wxSize * resultptr;
39639 resultptr = new wxSize(static_cast<wxSize & >(result));
39640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39641 }
39642 return resultobj;
39643 fail:
39644 return NULL;
39645 }
39646
39647
39648 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39649 PyObject *resultobj = NULL;
39650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39651 int arg2 ;
39652 int arg3 ;
39653 PyObject * obj0 = 0 ;
39654 PyObject * obj1 = 0 ;
39655 PyObject * obj2 = 0 ;
39656 char *kwnames[] = {
39657 (char *) "self",(char *) "x",(char *) "y", NULL
39658 };
39659
39660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39662 if (SWIG_arg_fail(1)) SWIG_fail;
39663 {
39664 arg2 = static_cast<int >(SWIG_As_int(obj1));
39665 if (SWIG_arg_fail(2)) SWIG_fail;
39666 }
39667 {
39668 arg3 = static_cast<int >(SWIG_As_int(obj2));
39669 if (SWIG_arg_fail(3)) SWIG_fail;
39670 }
39671 {
39672 PyThreadState* __tstate = wxPyBeginAllowThreads();
39673 (arg1)->SetInitSize(arg2,arg3);
39674
39675 wxPyEndAllowThreads(__tstate);
39676 if (PyErr_Occurred()) SWIG_fail;
39677 }
39678 Py_INCREF(Py_None); resultobj = Py_None;
39679 return resultobj;
39680 fail:
39681 return NULL;
39682 }
39683
39684
39685 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj = NULL;
39687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39688 int arg2 ;
39689 int arg3 ;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 PyObject * obj2 = 0 ;
39693 char *kwnames[] = {
39694 (char *) "self",(char *) "width",(char *) "height", NULL
39695 };
39696
39697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39699 if (SWIG_arg_fail(1)) SWIG_fail;
39700 {
39701 arg2 = static_cast<int >(SWIG_As_int(obj1));
39702 if (SWIG_arg_fail(2)) SWIG_fail;
39703 }
39704 {
39705 arg3 = static_cast<int >(SWIG_As_int(obj2));
39706 if (SWIG_arg_fail(3)) SWIG_fail;
39707 }
39708 {
39709 PyThreadState* __tstate = wxPyBeginAllowThreads();
39710 (arg1)->SetRatio(arg2,arg3);
39711
39712 wxPyEndAllowThreads(__tstate);
39713 if (PyErr_Occurred()) SWIG_fail;
39714 }
39715 Py_INCREF(Py_None); resultobj = Py_None;
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj = NULL;
39724 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39725 wxSize *arg2 = 0 ;
39726 wxSize temp2 ;
39727 PyObject * obj0 = 0 ;
39728 PyObject * obj1 = 0 ;
39729 char *kwnames[] = {
39730 (char *) "self",(char *) "size", NULL
39731 };
39732
39733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39735 if (SWIG_arg_fail(1)) SWIG_fail;
39736 {
39737 arg2 = &temp2;
39738 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39739 }
39740 {
39741 PyThreadState* __tstate = wxPyBeginAllowThreads();
39742 (arg1)->SetRatio((wxSize const &)*arg2);
39743
39744 wxPyEndAllowThreads(__tstate);
39745 if (PyErr_Occurred()) SWIG_fail;
39746 }
39747 Py_INCREF(Py_None); resultobj = Py_None;
39748 return resultobj;
39749 fail:
39750 return NULL;
39751 }
39752
39753
39754 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39755 PyObject *resultobj = NULL;
39756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39757 float arg2 ;
39758 PyObject * obj0 = 0 ;
39759 PyObject * obj1 = 0 ;
39760 char *kwnames[] = {
39761 (char *) "self",(char *) "ratio", NULL
39762 };
39763
39764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39766 if (SWIG_arg_fail(1)) SWIG_fail;
39767 {
39768 arg2 = static_cast<float >(SWIG_As_float(obj1));
39769 if (SWIG_arg_fail(2)) SWIG_fail;
39770 }
39771 {
39772 PyThreadState* __tstate = wxPyBeginAllowThreads();
39773 (arg1)->SetRatio(arg2);
39774
39775 wxPyEndAllowThreads(__tstate);
39776 if (PyErr_Occurred()) SWIG_fail;
39777 }
39778 Py_INCREF(Py_None); resultobj = Py_None;
39779 return resultobj;
39780 fail:
39781 return NULL;
39782 }
39783
39784
39785 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39786 PyObject *resultobj = NULL;
39787 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39788 float result;
39789 PyObject * obj0 = 0 ;
39790 char *kwnames[] = {
39791 (char *) "self", NULL
39792 };
39793
39794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39796 if (SWIG_arg_fail(1)) SWIG_fail;
39797 {
39798 PyThreadState* __tstate = wxPyBeginAllowThreads();
39799 result = (float)(arg1)->GetRatio();
39800
39801 wxPyEndAllowThreads(__tstate);
39802 if (PyErr_Occurred()) SWIG_fail;
39803 }
39804 {
39805 resultobj = SWIG_From_float(static_cast<float >(result));
39806 }
39807 return resultobj;
39808 fail:
39809 return NULL;
39810 }
39811
39812
39813 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39814 PyObject *resultobj = NULL;
39815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39816 wxRect result;
39817 PyObject * obj0 = 0 ;
39818 char *kwnames[] = {
39819 (char *) "self", NULL
39820 };
39821
39822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39824 if (SWIG_arg_fail(1)) SWIG_fail;
39825 {
39826 PyThreadState* __tstate = wxPyBeginAllowThreads();
39827 result = (arg1)->GetRect();
39828
39829 wxPyEndAllowThreads(__tstate);
39830 if (PyErr_Occurred()) SWIG_fail;
39831 }
39832 {
39833 wxRect * resultptr;
39834 resultptr = new wxRect(static_cast<wxRect & >(result));
39835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39836 }
39837 return resultobj;
39838 fail:
39839 return NULL;
39840 }
39841
39842
39843 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39844 PyObject *resultobj = NULL;
39845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39846 bool result;
39847 PyObject * obj0 = 0 ;
39848 char *kwnames[] = {
39849 (char *) "self", NULL
39850 };
39851
39852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39854 if (SWIG_arg_fail(1)) SWIG_fail;
39855 {
39856 PyThreadState* __tstate = wxPyBeginAllowThreads();
39857 result = (bool)(arg1)->IsWindow();
39858
39859 wxPyEndAllowThreads(__tstate);
39860 if (PyErr_Occurred()) SWIG_fail;
39861 }
39862 {
39863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39864 }
39865 return resultobj;
39866 fail:
39867 return NULL;
39868 }
39869
39870
39871 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39872 PyObject *resultobj = NULL;
39873 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39874 bool result;
39875 PyObject * obj0 = 0 ;
39876 char *kwnames[] = {
39877 (char *) "self", NULL
39878 };
39879
39880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39882 if (SWIG_arg_fail(1)) SWIG_fail;
39883 {
39884 PyThreadState* __tstate = wxPyBeginAllowThreads();
39885 result = (bool)(arg1)->IsSizer();
39886
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 {
39891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39892 }
39893 return resultobj;
39894 fail:
39895 return NULL;
39896 }
39897
39898
39899 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39900 PyObject *resultobj = NULL;
39901 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39902 bool result;
39903 PyObject * obj0 = 0 ;
39904 char *kwnames[] = {
39905 (char *) "self", NULL
39906 };
39907
39908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39910 if (SWIG_arg_fail(1)) SWIG_fail;
39911 {
39912 PyThreadState* __tstate = wxPyBeginAllowThreads();
39913 result = (bool)(arg1)->IsSpacer();
39914
39915 wxPyEndAllowThreads(__tstate);
39916 if (PyErr_Occurred()) SWIG_fail;
39917 }
39918 {
39919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39920 }
39921 return resultobj;
39922 fail:
39923 return NULL;
39924 }
39925
39926
39927 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39928 PyObject *resultobj = NULL;
39929 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39930 int arg2 ;
39931 PyObject * obj0 = 0 ;
39932 PyObject * obj1 = 0 ;
39933 char *kwnames[] = {
39934 (char *) "self",(char *) "proportion", NULL
39935 };
39936
39937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39939 if (SWIG_arg_fail(1)) SWIG_fail;
39940 {
39941 arg2 = static_cast<int >(SWIG_As_int(obj1));
39942 if (SWIG_arg_fail(2)) SWIG_fail;
39943 }
39944 {
39945 PyThreadState* __tstate = wxPyBeginAllowThreads();
39946 (arg1)->SetProportion(arg2);
39947
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 Py_INCREF(Py_None); resultobj = Py_None;
39952 return resultobj;
39953 fail:
39954 return NULL;
39955 }
39956
39957
39958 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39959 PyObject *resultobj = NULL;
39960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39961 int result;
39962 PyObject * obj0 = 0 ;
39963 char *kwnames[] = {
39964 (char *) "self", NULL
39965 };
39966
39967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39969 if (SWIG_arg_fail(1)) SWIG_fail;
39970 {
39971 PyThreadState* __tstate = wxPyBeginAllowThreads();
39972 result = (int)(arg1)->GetProportion();
39973
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 {
39978 resultobj = SWIG_From_int(static_cast<int >(result));
39979 }
39980 return resultobj;
39981 fail:
39982 return NULL;
39983 }
39984
39985
39986 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39987 PyObject *resultobj = NULL;
39988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39989 int arg2 ;
39990 PyObject * obj0 = 0 ;
39991 PyObject * obj1 = 0 ;
39992 char *kwnames[] = {
39993 (char *) "self",(char *) "flag", NULL
39994 };
39995
39996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39998 if (SWIG_arg_fail(1)) SWIG_fail;
39999 {
40000 arg2 = static_cast<int >(SWIG_As_int(obj1));
40001 if (SWIG_arg_fail(2)) SWIG_fail;
40002 }
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 (arg1)->SetFlag(arg2);
40006
40007 wxPyEndAllowThreads(__tstate);
40008 if (PyErr_Occurred()) SWIG_fail;
40009 }
40010 Py_INCREF(Py_None); resultobj = Py_None;
40011 return resultobj;
40012 fail:
40013 return NULL;
40014 }
40015
40016
40017 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40018 PyObject *resultobj = NULL;
40019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40020 int result;
40021 PyObject * obj0 = 0 ;
40022 char *kwnames[] = {
40023 (char *) "self", NULL
40024 };
40025
40026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40028 if (SWIG_arg_fail(1)) SWIG_fail;
40029 {
40030 PyThreadState* __tstate = wxPyBeginAllowThreads();
40031 result = (int)(arg1)->GetFlag();
40032
40033 wxPyEndAllowThreads(__tstate);
40034 if (PyErr_Occurred()) SWIG_fail;
40035 }
40036 {
40037 resultobj = SWIG_From_int(static_cast<int >(result));
40038 }
40039 return resultobj;
40040 fail:
40041 return NULL;
40042 }
40043
40044
40045 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40046 PyObject *resultobj = NULL;
40047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40048 int arg2 ;
40049 PyObject * obj0 = 0 ;
40050 PyObject * obj1 = 0 ;
40051 char *kwnames[] = {
40052 (char *) "self",(char *) "border", NULL
40053 };
40054
40055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40057 if (SWIG_arg_fail(1)) SWIG_fail;
40058 {
40059 arg2 = static_cast<int >(SWIG_As_int(obj1));
40060 if (SWIG_arg_fail(2)) SWIG_fail;
40061 }
40062 {
40063 PyThreadState* __tstate = wxPyBeginAllowThreads();
40064 (arg1)->SetBorder(arg2);
40065
40066 wxPyEndAllowThreads(__tstate);
40067 if (PyErr_Occurred()) SWIG_fail;
40068 }
40069 Py_INCREF(Py_None); resultobj = Py_None;
40070 return resultobj;
40071 fail:
40072 return NULL;
40073 }
40074
40075
40076 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40077 PyObject *resultobj = NULL;
40078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40079 int result;
40080 PyObject * obj0 = 0 ;
40081 char *kwnames[] = {
40082 (char *) "self", NULL
40083 };
40084
40085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40087 if (SWIG_arg_fail(1)) SWIG_fail;
40088 {
40089 PyThreadState* __tstate = wxPyBeginAllowThreads();
40090 result = (int)(arg1)->GetBorder();
40091
40092 wxPyEndAllowThreads(__tstate);
40093 if (PyErr_Occurred()) SWIG_fail;
40094 }
40095 {
40096 resultobj = SWIG_From_int(static_cast<int >(result));
40097 }
40098 return resultobj;
40099 fail:
40100 return NULL;
40101 }
40102
40103
40104 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40105 PyObject *resultobj = NULL;
40106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40107 wxWindow *result;
40108 PyObject * obj0 = 0 ;
40109 char *kwnames[] = {
40110 (char *) "self", NULL
40111 };
40112
40113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40115 if (SWIG_arg_fail(1)) SWIG_fail;
40116 {
40117 PyThreadState* __tstate = wxPyBeginAllowThreads();
40118 result = (wxWindow *)(arg1)->GetWindow();
40119
40120 wxPyEndAllowThreads(__tstate);
40121 if (PyErr_Occurred()) SWIG_fail;
40122 }
40123 {
40124 resultobj = wxPyMake_wxObject(result, 0);
40125 }
40126 return resultobj;
40127 fail:
40128 return NULL;
40129 }
40130
40131
40132 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40133 PyObject *resultobj = NULL;
40134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40135 wxWindow *arg2 = (wxWindow *) 0 ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 char *kwnames[] = {
40139 (char *) "self",(char *) "window", NULL
40140 };
40141
40142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40144 if (SWIG_arg_fail(1)) SWIG_fail;
40145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40146 if (SWIG_arg_fail(2)) SWIG_fail;
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 (arg1)->SetWindow(arg2);
40150
40151 wxPyEndAllowThreads(__tstate);
40152 if (PyErr_Occurred()) SWIG_fail;
40153 }
40154 Py_INCREF(Py_None); resultobj = Py_None;
40155 return resultobj;
40156 fail:
40157 return NULL;
40158 }
40159
40160
40161 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40162 PyObject *resultobj = NULL;
40163 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40164 wxSizer *result;
40165 PyObject * obj0 = 0 ;
40166 char *kwnames[] = {
40167 (char *) "self", NULL
40168 };
40169
40170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40172 if (SWIG_arg_fail(1)) SWIG_fail;
40173 {
40174 PyThreadState* __tstate = wxPyBeginAllowThreads();
40175 result = (wxSizer *)(arg1)->GetSizer();
40176
40177 wxPyEndAllowThreads(__tstate);
40178 if (PyErr_Occurred()) SWIG_fail;
40179 }
40180 {
40181 resultobj = wxPyMake_wxObject(result, 0);
40182 }
40183 return resultobj;
40184 fail:
40185 return NULL;
40186 }
40187
40188
40189 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40190 PyObject *resultobj = NULL;
40191 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40192 wxSizer *arg2 = (wxSizer *) 0 ;
40193 PyObject * obj0 = 0 ;
40194 PyObject * obj1 = 0 ;
40195 char *kwnames[] = {
40196 (char *) "self",(char *) "sizer", NULL
40197 };
40198
40199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40201 if (SWIG_arg_fail(1)) SWIG_fail;
40202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40203 if (SWIG_arg_fail(2)) SWIG_fail;
40204 {
40205 PyThreadState* __tstate = wxPyBeginAllowThreads();
40206 (arg1)->SetSizer(arg2);
40207
40208 wxPyEndAllowThreads(__tstate);
40209 if (PyErr_Occurred()) SWIG_fail;
40210 }
40211 Py_INCREF(Py_None); resultobj = Py_None;
40212 return resultobj;
40213 fail:
40214 return NULL;
40215 }
40216
40217
40218 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40219 PyObject *resultobj = NULL;
40220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40221 wxSize *result;
40222 PyObject * obj0 = 0 ;
40223 char *kwnames[] = {
40224 (char *) "self", NULL
40225 };
40226
40227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40229 if (SWIG_arg_fail(1)) SWIG_fail;
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 {
40233 wxSize const &_result_ref = (arg1)->GetSpacer();
40234 result = (wxSize *) &_result_ref;
40235 }
40236
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40241 return resultobj;
40242 fail:
40243 return NULL;
40244 }
40245
40246
40247 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj = NULL;
40249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40250 wxSize *arg2 = 0 ;
40251 wxSize temp2 ;
40252 PyObject * obj0 = 0 ;
40253 PyObject * obj1 = 0 ;
40254 char *kwnames[] = {
40255 (char *) "self",(char *) "size", NULL
40256 };
40257
40258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(1)) SWIG_fail;
40261 {
40262 arg2 = &temp2;
40263 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40264 }
40265 {
40266 PyThreadState* __tstate = wxPyBeginAllowThreads();
40267 (arg1)->SetSpacer((wxSize const &)*arg2);
40268
40269 wxPyEndAllowThreads(__tstate);
40270 if (PyErr_Occurred()) SWIG_fail;
40271 }
40272 Py_INCREF(Py_None); resultobj = Py_None;
40273 return resultobj;
40274 fail:
40275 return NULL;
40276 }
40277
40278
40279 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40280 PyObject *resultobj = NULL;
40281 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40282 bool arg2 ;
40283 PyObject * obj0 = 0 ;
40284 PyObject * obj1 = 0 ;
40285 char *kwnames[] = {
40286 (char *) "self",(char *) "show", NULL
40287 };
40288
40289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40291 if (SWIG_arg_fail(1)) SWIG_fail;
40292 {
40293 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40294 if (SWIG_arg_fail(2)) SWIG_fail;
40295 }
40296 {
40297 PyThreadState* __tstate = wxPyBeginAllowThreads();
40298 (arg1)->Show(arg2);
40299
40300 wxPyEndAllowThreads(__tstate);
40301 if (PyErr_Occurred()) SWIG_fail;
40302 }
40303 Py_INCREF(Py_None); resultobj = Py_None;
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj = NULL;
40312 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40313 bool result;
40314 PyObject * obj0 = 0 ;
40315 char *kwnames[] = {
40316 (char *) "self", NULL
40317 };
40318
40319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40321 if (SWIG_arg_fail(1)) SWIG_fail;
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 result = (bool)(arg1)->IsShown();
40325
40326 wxPyEndAllowThreads(__tstate);
40327 if (PyErr_Occurred()) SWIG_fail;
40328 }
40329 {
40330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40331 }
40332 return resultobj;
40333 fail:
40334 return NULL;
40335 }
40336
40337
40338 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40339 PyObject *resultobj = NULL;
40340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40341 wxPoint result;
40342 PyObject * obj0 = 0 ;
40343 char *kwnames[] = {
40344 (char *) "self", NULL
40345 };
40346
40347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40349 if (SWIG_arg_fail(1)) SWIG_fail;
40350 {
40351 PyThreadState* __tstate = wxPyBeginAllowThreads();
40352 result = (arg1)->GetPosition();
40353
40354 wxPyEndAllowThreads(__tstate);
40355 if (PyErr_Occurred()) SWIG_fail;
40356 }
40357 {
40358 wxPoint * resultptr;
40359 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40361 }
40362 return resultobj;
40363 fail:
40364 return NULL;
40365 }
40366
40367
40368 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40369 PyObject *resultobj = NULL;
40370 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40371 PyObject *result;
40372 PyObject * obj0 = 0 ;
40373 char *kwnames[] = {
40374 (char *) "self", NULL
40375 };
40376
40377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40379 if (SWIG_arg_fail(1)) SWIG_fail;
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40383
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 resultobj = result;
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40395 PyObject *resultobj = NULL;
40396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40397 PyObject *arg2 = (PyObject *) 0 ;
40398 PyObject * obj0 = 0 ;
40399 PyObject * obj1 = 0 ;
40400 char *kwnames[] = {
40401 (char *) "self",(char *) "userData", NULL
40402 };
40403
40404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40406 if (SWIG_arg_fail(1)) SWIG_fail;
40407 arg2 = obj1;
40408 {
40409 PyThreadState* __tstate = wxPyBeginAllowThreads();
40410 wxSizerItem_SetUserData(arg1,arg2);
40411
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 Py_INCREF(Py_None); resultobj = Py_None;
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40423 PyObject *obj;
40424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40425 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40426 Py_INCREF(obj);
40427 return Py_BuildValue((char *)"");
40428 }
40429 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40430 PyObject *resultobj = NULL;
40431 wxSizer *arg1 = (wxSizer *) 0 ;
40432 PyObject *arg2 = (PyObject *) 0 ;
40433 PyObject * obj0 = 0 ;
40434 PyObject * obj1 = 0 ;
40435 char *kwnames[] = {
40436 (char *) "self",(char *) "_self", NULL
40437 };
40438
40439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40441 if (SWIG_arg_fail(1)) SWIG_fail;
40442 arg2 = obj1;
40443 {
40444 PyThreadState* __tstate = wxPyBeginAllowThreads();
40445 wxSizer__setOORInfo(arg1,arg2);
40446
40447 wxPyEndAllowThreads(__tstate);
40448 if (PyErr_Occurred()) SWIG_fail;
40449 }
40450 Py_INCREF(Py_None); resultobj = Py_None;
40451 return resultobj;
40452 fail:
40453 return NULL;
40454 }
40455
40456
40457 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40458 PyObject *resultobj = NULL;
40459 wxSizer *arg1 = (wxSizer *) 0 ;
40460 PyObject *arg2 = (PyObject *) 0 ;
40461 int arg3 = (int) 0 ;
40462 int arg4 = (int) 0 ;
40463 int arg5 = (int) 0 ;
40464 PyObject *arg6 = (PyObject *) NULL ;
40465 wxSizerItem *result;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 PyObject * obj2 = 0 ;
40469 PyObject * obj3 = 0 ;
40470 PyObject * obj4 = 0 ;
40471 PyObject * obj5 = 0 ;
40472 char *kwnames[] = {
40473 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40474 };
40475
40476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40478 if (SWIG_arg_fail(1)) SWIG_fail;
40479 arg2 = obj1;
40480 if (obj2) {
40481 {
40482 arg3 = static_cast<int >(SWIG_As_int(obj2));
40483 if (SWIG_arg_fail(3)) SWIG_fail;
40484 }
40485 }
40486 if (obj3) {
40487 {
40488 arg4 = static_cast<int >(SWIG_As_int(obj3));
40489 if (SWIG_arg_fail(4)) SWIG_fail;
40490 }
40491 }
40492 if (obj4) {
40493 {
40494 arg5 = static_cast<int >(SWIG_As_int(obj4));
40495 if (SWIG_arg_fail(5)) SWIG_fail;
40496 }
40497 }
40498 if (obj5) {
40499 arg6 = obj5;
40500 }
40501 {
40502 PyThreadState* __tstate = wxPyBeginAllowThreads();
40503 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40504
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40509 return resultobj;
40510 fail:
40511 return NULL;
40512 }
40513
40514
40515 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40516 PyObject *resultobj = NULL;
40517 wxSizer *arg1 = (wxSizer *) 0 ;
40518 int arg2 ;
40519 PyObject *arg3 = (PyObject *) 0 ;
40520 int arg4 = (int) 0 ;
40521 int arg5 = (int) 0 ;
40522 int arg6 = (int) 0 ;
40523 PyObject *arg7 = (PyObject *) NULL ;
40524 wxSizerItem *result;
40525 PyObject * obj0 = 0 ;
40526 PyObject * obj1 = 0 ;
40527 PyObject * obj2 = 0 ;
40528 PyObject * obj3 = 0 ;
40529 PyObject * obj4 = 0 ;
40530 PyObject * obj5 = 0 ;
40531 PyObject * obj6 = 0 ;
40532 char *kwnames[] = {
40533 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40534 };
40535
40536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40538 if (SWIG_arg_fail(1)) SWIG_fail;
40539 {
40540 arg2 = static_cast<int >(SWIG_As_int(obj1));
40541 if (SWIG_arg_fail(2)) SWIG_fail;
40542 }
40543 arg3 = obj2;
40544 if (obj3) {
40545 {
40546 arg4 = static_cast<int >(SWIG_As_int(obj3));
40547 if (SWIG_arg_fail(4)) SWIG_fail;
40548 }
40549 }
40550 if (obj4) {
40551 {
40552 arg5 = static_cast<int >(SWIG_As_int(obj4));
40553 if (SWIG_arg_fail(5)) SWIG_fail;
40554 }
40555 }
40556 if (obj5) {
40557 {
40558 arg6 = static_cast<int >(SWIG_As_int(obj5));
40559 if (SWIG_arg_fail(6)) SWIG_fail;
40560 }
40561 }
40562 if (obj6) {
40563 arg7 = obj6;
40564 }
40565 {
40566 PyThreadState* __tstate = wxPyBeginAllowThreads();
40567 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40568
40569 wxPyEndAllowThreads(__tstate);
40570 if (PyErr_Occurred()) SWIG_fail;
40571 }
40572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40573 return resultobj;
40574 fail:
40575 return NULL;
40576 }
40577
40578
40579 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40580 PyObject *resultobj = NULL;
40581 wxSizer *arg1 = (wxSizer *) 0 ;
40582 PyObject *arg2 = (PyObject *) 0 ;
40583 int arg3 = (int) 0 ;
40584 int arg4 = (int) 0 ;
40585 int arg5 = (int) 0 ;
40586 PyObject *arg6 = (PyObject *) NULL ;
40587 wxSizerItem *result;
40588 PyObject * obj0 = 0 ;
40589 PyObject * obj1 = 0 ;
40590 PyObject * obj2 = 0 ;
40591 PyObject * obj3 = 0 ;
40592 PyObject * obj4 = 0 ;
40593 PyObject * obj5 = 0 ;
40594 char *kwnames[] = {
40595 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40596 };
40597
40598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40600 if (SWIG_arg_fail(1)) SWIG_fail;
40601 arg2 = obj1;
40602 if (obj2) {
40603 {
40604 arg3 = static_cast<int >(SWIG_As_int(obj2));
40605 if (SWIG_arg_fail(3)) SWIG_fail;
40606 }
40607 }
40608 if (obj3) {
40609 {
40610 arg4 = static_cast<int >(SWIG_As_int(obj3));
40611 if (SWIG_arg_fail(4)) SWIG_fail;
40612 }
40613 }
40614 if (obj4) {
40615 {
40616 arg5 = static_cast<int >(SWIG_As_int(obj4));
40617 if (SWIG_arg_fail(5)) SWIG_fail;
40618 }
40619 }
40620 if (obj5) {
40621 arg6 = obj5;
40622 }
40623 {
40624 PyThreadState* __tstate = wxPyBeginAllowThreads();
40625 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40626
40627 wxPyEndAllowThreads(__tstate);
40628 if (PyErr_Occurred()) SWIG_fail;
40629 }
40630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40631 return resultobj;
40632 fail:
40633 return NULL;
40634 }
40635
40636
40637 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40638 PyObject *resultobj = NULL;
40639 wxSizer *arg1 = (wxSizer *) 0 ;
40640 PyObject *arg2 = (PyObject *) 0 ;
40641 bool result;
40642 PyObject * obj0 = 0 ;
40643 PyObject * obj1 = 0 ;
40644 char *kwnames[] = {
40645 (char *) "self",(char *) "item", NULL
40646 };
40647
40648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40650 if (SWIG_arg_fail(1)) SWIG_fail;
40651 arg2 = obj1;
40652 {
40653 PyThreadState* __tstate = wxPyBeginAllowThreads();
40654 result = (bool)wxSizer_Remove(arg1,arg2);
40655
40656 wxPyEndAllowThreads(__tstate);
40657 if (PyErr_Occurred()) SWIG_fail;
40658 }
40659 {
40660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40661 }
40662 return resultobj;
40663 fail:
40664 return NULL;
40665 }
40666
40667
40668 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40669 PyObject *resultobj = NULL;
40670 wxSizer *arg1 = (wxSizer *) 0 ;
40671 PyObject *arg2 = (PyObject *) 0 ;
40672 bool result;
40673 PyObject * obj0 = 0 ;
40674 PyObject * obj1 = 0 ;
40675 char *kwnames[] = {
40676 (char *) "self",(char *) "item", NULL
40677 };
40678
40679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40681 if (SWIG_arg_fail(1)) SWIG_fail;
40682 arg2 = obj1;
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 result = (bool)wxSizer_Detach(arg1,arg2);
40686
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 {
40691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40692 }
40693 return resultobj;
40694 fail:
40695 return NULL;
40696 }
40697
40698
40699 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40700 PyObject *resultobj = NULL;
40701 wxSizer *arg1 = (wxSizer *) 0 ;
40702 PyObject *arg2 = (PyObject *) 0 ;
40703 wxSizerItem *result;
40704 PyObject * obj0 = 0 ;
40705 PyObject * obj1 = 0 ;
40706 char *kwnames[] = {
40707 (char *) "self",(char *) "item", NULL
40708 };
40709
40710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40712 if (SWIG_arg_fail(1)) SWIG_fail;
40713 arg2 = obj1;
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40717
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40722 return resultobj;
40723 fail:
40724 return NULL;
40725 }
40726
40727
40728 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40729 PyObject *resultobj = NULL;
40730 wxSizer *arg1 = (wxSizer *) 0 ;
40731 PyObject *arg2 = (PyObject *) 0 ;
40732 wxSize *arg3 = 0 ;
40733 wxSize temp3 ;
40734 PyObject * obj0 = 0 ;
40735 PyObject * obj1 = 0 ;
40736 PyObject * obj2 = 0 ;
40737 char *kwnames[] = {
40738 (char *) "self",(char *) "item",(char *) "size", NULL
40739 };
40740
40741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40743 if (SWIG_arg_fail(1)) SWIG_fail;
40744 arg2 = obj1;
40745 {
40746 arg3 = &temp3;
40747 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40748 }
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40752
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 Py_INCREF(Py_None); resultobj = Py_None;
40757 return resultobj;
40758 fail:
40759 return NULL;
40760 }
40761
40762
40763 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40764 PyObject *resultobj = NULL;
40765 wxSizer *arg1 = (wxSizer *) 0 ;
40766 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40767 wxSizerItem *result;
40768 PyObject * obj0 = 0 ;
40769 PyObject * obj1 = 0 ;
40770 char *kwnames[] = {
40771 (char *) "self",(char *) "item", NULL
40772 };
40773
40774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40776 if (SWIG_arg_fail(1)) SWIG_fail;
40777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40778 if (SWIG_arg_fail(2)) SWIG_fail;
40779 {
40780 PyThreadState* __tstate = wxPyBeginAllowThreads();
40781 result = (wxSizerItem *)(arg1)->Add(arg2);
40782
40783 wxPyEndAllowThreads(__tstate);
40784 if (PyErr_Occurred()) SWIG_fail;
40785 }
40786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40787 return resultobj;
40788 fail:
40789 return NULL;
40790 }
40791
40792
40793 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40794 PyObject *resultobj = NULL;
40795 wxSizer *arg1 = (wxSizer *) 0 ;
40796 size_t arg2 ;
40797 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40798 wxSizerItem *result;
40799 PyObject * obj0 = 0 ;
40800 PyObject * obj1 = 0 ;
40801 PyObject * obj2 = 0 ;
40802 char *kwnames[] = {
40803 (char *) "self",(char *) "index",(char *) "item", NULL
40804 };
40805
40806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40808 if (SWIG_arg_fail(1)) SWIG_fail;
40809 {
40810 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40811 if (SWIG_arg_fail(2)) SWIG_fail;
40812 }
40813 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40814 if (SWIG_arg_fail(3)) SWIG_fail;
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40818
40819 wxPyEndAllowThreads(__tstate);
40820 if (PyErr_Occurred()) SWIG_fail;
40821 }
40822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40823 return resultobj;
40824 fail:
40825 return NULL;
40826 }
40827
40828
40829 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40830 PyObject *resultobj = NULL;
40831 wxSizer *arg1 = (wxSizer *) 0 ;
40832 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40833 wxSizerItem *result;
40834 PyObject * obj0 = 0 ;
40835 PyObject * obj1 = 0 ;
40836 char *kwnames[] = {
40837 (char *) "self",(char *) "item", NULL
40838 };
40839
40840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40842 if (SWIG_arg_fail(1)) SWIG_fail;
40843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40844 if (SWIG_arg_fail(2)) SWIG_fail;
40845 {
40846 PyThreadState* __tstate = wxPyBeginAllowThreads();
40847 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40848
40849 wxPyEndAllowThreads(__tstate);
40850 if (PyErr_Occurred()) SWIG_fail;
40851 }
40852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40853 return resultobj;
40854 fail:
40855 return NULL;
40856 }
40857
40858
40859 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40860 PyObject *resultobj = NULL;
40861 wxSizer *arg1 = (wxSizer *) 0 ;
40862 int arg2 ;
40863 int arg3 ;
40864 int arg4 ;
40865 int arg5 ;
40866 PyObject * obj0 = 0 ;
40867 PyObject * obj1 = 0 ;
40868 PyObject * obj2 = 0 ;
40869 PyObject * obj3 = 0 ;
40870 PyObject * obj4 = 0 ;
40871 char *kwnames[] = {
40872 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40873 };
40874
40875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40877 if (SWIG_arg_fail(1)) SWIG_fail;
40878 {
40879 arg2 = static_cast<int >(SWIG_As_int(obj1));
40880 if (SWIG_arg_fail(2)) SWIG_fail;
40881 }
40882 {
40883 arg3 = static_cast<int >(SWIG_As_int(obj2));
40884 if (SWIG_arg_fail(3)) SWIG_fail;
40885 }
40886 {
40887 arg4 = static_cast<int >(SWIG_As_int(obj3));
40888 if (SWIG_arg_fail(4)) SWIG_fail;
40889 }
40890 {
40891 arg5 = static_cast<int >(SWIG_As_int(obj4));
40892 if (SWIG_arg_fail(5)) SWIG_fail;
40893 }
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40897
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 Py_INCREF(Py_None); resultobj = Py_None;
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40909 PyObject *resultobj = NULL;
40910 wxSizer *arg1 = (wxSizer *) 0 ;
40911 wxSize *arg2 = 0 ;
40912 wxSize temp2 ;
40913 PyObject * obj0 = 0 ;
40914 PyObject * obj1 = 0 ;
40915 char *kwnames[] = {
40916 (char *) "self",(char *) "size", NULL
40917 };
40918
40919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40921 if (SWIG_arg_fail(1)) SWIG_fail;
40922 {
40923 arg2 = &temp2;
40924 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40925 }
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 (arg1)->SetMinSize((wxSize const &)*arg2);
40929
40930 wxPyEndAllowThreads(__tstate);
40931 if (PyErr_Occurred()) SWIG_fail;
40932 }
40933 Py_INCREF(Py_None); resultobj = Py_None;
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40941 PyObject *resultobj = NULL;
40942 wxSizer *arg1 = (wxSizer *) 0 ;
40943 wxSize result;
40944 PyObject * obj0 = 0 ;
40945 char *kwnames[] = {
40946 (char *) "self", NULL
40947 };
40948
40949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40951 if (SWIG_arg_fail(1)) SWIG_fail;
40952 {
40953 PyThreadState* __tstate = wxPyBeginAllowThreads();
40954 result = (arg1)->GetSize();
40955
40956 wxPyEndAllowThreads(__tstate);
40957 if (PyErr_Occurred()) SWIG_fail;
40958 }
40959 {
40960 wxSize * resultptr;
40961 resultptr = new wxSize(static_cast<wxSize & >(result));
40962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40963 }
40964 return resultobj;
40965 fail:
40966 return NULL;
40967 }
40968
40969
40970 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40971 PyObject *resultobj = NULL;
40972 wxSizer *arg1 = (wxSizer *) 0 ;
40973 wxPoint result;
40974 PyObject * obj0 = 0 ;
40975 char *kwnames[] = {
40976 (char *) "self", NULL
40977 };
40978
40979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40981 if (SWIG_arg_fail(1)) SWIG_fail;
40982 {
40983 PyThreadState* __tstate = wxPyBeginAllowThreads();
40984 result = (arg1)->GetPosition();
40985
40986 wxPyEndAllowThreads(__tstate);
40987 if (PyErr_Occurred()) SWIG_fail;
40988 }
40989 {
40990 wxPoint * resultptr;
40991 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40993 }
40994 return resultobj;
40995 fail:
40996 return NULL;
40997 }
40998
40999
41000 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41001 PyObject *resultobj = NULL;
41002 wxSizer *arg1 = (wxSizer *) 0 ;
41003 wxSize result;
41004 PyObject * obj0 = 0 ;
41005 char *kwnames[] = {
41006 (char *) "self", NULL
41007 };
41008
41009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41011 if (SWIG_arg_fail(1)) SWIG_fail;
41012 {
41013 PyThreadState* __tstate = wxPyBeginAllowThreads();
41014 result = (arg1)->GetMinSize();
41015
41016 wxPyEndAllowThreads(__tstate);
41017 if (PyErr_Occurred()) SWIG_fail;
41018 }
41019 {
41020 wxSize * resultptr;
41021 resultptr = new wxSize(static_cast<wxSize & >(result));
41022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41023 }
41024 return resultobj;
41025 fail:
41026 return NULL;
41027 }
41028
41029
41030 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41031 PyObject *resultobj = NULL;
41032 wxSizer *arg1 = (wxSizer *) 0 ;
41033 PyObject * obj0 = 0 ;
41034 char *kwnames[] = {
41035 (char *) "self", NULL
41036 };
41037
41038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41040 if (SWIG_arg_fail(1)) SWIG_fail;
41041 {
41042 PyThreadState* __tstate = wxPyBeginAllowThreads();
41043 (arg1)->RecalcSizes();
41044
41045 wxPyEndAllowThreads(__tstate);
41046 if (PyErr_Occurred()) SWIG_fail;
41047 }
41048 Py_INCREF(Py_None); resultobj = Py_None;
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj = NULL;
41057 wxSizer *arg1 = (wxSizer *) 0 ;
41058 wxSize result;
41059 PyObject * obj0 = 0 ;
41060 char *kwnames[] = {
41061 (char *) "self", NULL
41062 };
41063
41064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41066 if (SWIG_arg_fail(1)) SWIG_fail;
41067 {
41068 PyThreadState* __tstate = wxPyBeginAllowThreads();
41069 result = (arg1)->CalcMin();
41070
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 {
41075 wxSize * resultptr;
41076 resultptr = new wxSize(static_cast<wxSize & >(result));
41077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41078 }
41079 return resultobj;
41080 fail:
41081 return NULL;
41082 }
41083
41084
41085 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41086 PyObject *resultobj = NULL;
41087 wxSizer *arg1 = (wxSizer *) 0 ;
41088 PyObject * obj0 = 0 ;
41089 char *kwnames[] = {
41090 (char *) "self", NULL
41091 };
41092
41093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41095 if (SWIG_arg_fail(1)) SWIG_fail;
41096 {
41097 PyThreadState* __tstate = wxPyBeginAllowThreads();
41098 (arg1)->Layout();
41099
41100 wxPyEndAllowThreads(__tstate);
41101 if (PyErr_Occurred()) SWIG_fail;
41102 }
41103 Py_INCREF(Py_None); resultobj = Py_None;
41104 return resultobj;
41105 fail:
41106 return NULL;
41107 }
41108
41109
41110 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj = NULL;
41112 wxSizer *arg1 = (wxSizer *) 0 ;
41113 wxWindow *arg2 = (wxWindow *) 0 ;
41114 wxSize result;
41115 PyObject * obj0 = 0 ;
41116 PyObject * obj1 = 0 ;
41117 char *kwnames[] = {
41118 (char *) "self",(char *) "window", NULL
41119 };
41120
41121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41123 if (SWIG_arg_fail(1)) SWIG_fail;
41124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41125 if (SWIG_arg_fail(2)) SWIG_fail;
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 result = (arg1)->Fit(arg2);
41129
41130 wxPyEndAllowThreads(__tstate);
41131 if (PyErr_Occurred()) SWIG_fail;
41132 }
41133 {
41134 wxSize * resultptr;
41135 resultptr = new wxSize(static_cast<wxSize & >(result));
41136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41137 }
41138 return resultobj;
41139 fail:
41140 return NULL;
41141 }
41142
41143
41144 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj = NULL;
41146 wxSizer *arg1 = (wxSizer *) 0 ;
41147 wxWindow *arg2 = (wxWindow *) 0 ;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 char *kwnames[] = {
41151 (char *) "self",(char *) "window", NULL
41152 };
41153
41154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41156 if (SWIG_arg_fail(1)) SWIG_fail;
41157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41158 if (SWIG_arg_fail(2)) SWIG_fail;
41159 {
41160 PyThreadState* __tstate = wxPyBeginAllowThreads();
41161 (arg1)->FitInside(arg2);
41162
41163 wxPyEndAllowThreads(__tstate);
41164 if (PyErr_Occurred()) SWIG_fail;
41165 }
41166 Py_INCREF(Py_None); resultobj = Py_None;
41167 return resultobj;
41168 fail:
41169 return NULL;
41170 }
41171
41172
41173 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41174 PyObject *resultobj = NULL;
41175 wxSizer *arg1 = (wxSizer *) 0 ;
41176 wxWindow *arg2 = (wxWindow *) 0 ;
41177 PyObject * obj0 = 0 ;
41178 PyObject * obj1 = 0 ;
41179 char *kwnames[] = {
41180 (char *) "self",(char *) "window", NULL
41181 };
41182
41183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41185 if (SWIG_arg_fail(1)) SWIG_fail;
41186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41187 if (SWIG_arg_fail(2)) SWIG_fail;
41188 {
41189 PyThreadState* __tstate = wxPyBeginAllowThreads();
41190 (arg1)->SetSizeHints(arg2);
41191
41192 wxPyEndAllowThreads(__tstate);
41193 if (PyErr_Occurred()) SWIG_fail;
41194 }
41195 Py_INCREF(Py_None); resultobj = Py_None;
41196 return resultobj;
41197 fail:
41198 return NULL;
41199 }
41200
41201
41202 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41203 PyObject *resultobj = NULL;
41204 wxSizer *arg1 = (wxSizer *) 0 ;
41205 wxWindow *arg2 = (wxWindow *) 0 ;
41206 PyObject * obj0 = 0 ;
41207 PyObject * obj1 = 0 ;
41208 char *kwnames[] = {
41209 (char *) "self",(char *) "window", NULL
41210 };
41211
41212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41214 if (SWIG_arg_fail(1)) SWIG_fail;
41215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41216 if (SWIG_arg_fail(2)) SWIG_fail;
41217 {
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 (arg1)->SetVirtualSizeHints(arg2);
41220
41221 wxPyEndAllowThreads(__tstate);
41222 if (PyErr_Occurred()) SWIG_fail;
41223 }
41224 Py_INCREF(Py_None); resultobj = Py_None;
41225 return resultobj;
41226 fail:
41227 return NULL;
41228 }
41229
41230
41231 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41232 PyObject *resultobj = NULL;
41233 wxSizer *arg1 = (wxSizer *) 0 ;
41234 bool arg2 = (bool) false ;
41235 PyObject * obj0 = 0 ;
41236 PyObject * obj1 = 0 ;
41237 char *kwnames[] = {
41238 (char *) "self",(char *) "deleteWindows", NULL
41239 };
41240
41241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41243 if (SWIG_arg_fail(1)) SWIG_fail;
41244 if (obj1) {
41245 {
41246 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41247 if (SWIG_arg_fail(2)) SWIG_fail;
41248 }
41249 }
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 (arg1)->Clear(arg2);
41253
41254 wxPyEndAllowThreads(__tstate);
41255 if (PyErr_Occurred()) SWIG_fail;
41256 }
41257 Py_INCREF(Py_None); resultobj = Py_None;
41258 return resultobj;
41259 fail:
41260 return NULL;
41261 }
41262
41263
41264 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj = NULL;
41266 wxSizer *arg1 = (wxSizer *) 0 ;
41267 PyObject * obj0 = 0 ;
41268 char *kwnames[] = {
41269 (char *) "self", NULL
41270 };
41271
41272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41274 if (SWIG_arg_fail(1)) SWIG_fail;
41275 {
41276 PyThreadState* __tstate = wxPyBeginAllowThreads();
41277 (arg1)->DeleteWindows();
41278
41279 wxPyEndAllowThreads(__tstate);
41280 if (PyErr_Occurred()) SWIG_fail;
41281 }
41282 Py_INCREF(Py_None); resultobj = Py_None;
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41290 PyObject *resultobj = NULL;
41291 wxSizer *arg1 = (wxSizer *) 0 ;
41292 PyObject *result;
41293 PyObject * obj0 = 0 ;
41294 char *kwnames[] = {
41295 (char *) "self", NULL
41296 };
41297
41298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41300 if (SWIG_arg_fail(1)) SWIG_fail;
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 result = (PyObject *)wxSizer_GetChildren(arg1);
41304
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 resultobj = result;
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj = NULL;
41317 wxSizer *arg1 = (wxSizer *) 0 ;
41318 PyObject *arg2 = (PyObject *) 0 ;
41319 bool arg3 = (bool) true ;
41320 bool arg4 = (bool) false ;
41321 bool result;
41322 PyObject * obj0 = 0 ;
41323 PyObject * obj1 = 0 ;
41324 PyObject * obj2 = 0 ;
41325 PyObject * obj3 = 0 ;
41326 char *kwnames[] = {
41327 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41328 };
41329
41330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41332 if (SWIG_arg_fail(1)) SWIG_fail;
41333 arg2 = obj1;
41334 if (obj2) {
41335 {
41336 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41337 if (SWIG_arg_fail(3)) SWIG_fail;
41338 }
41339 }
41340 if (obj3) {
41341 {
41342 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41343 if (SWIG_arg_fail(4)) SWIG_fail;
41344 }
41345 }
41346 {
41347 PyThreadState* __tstate = wxPyBeginAllowThreads();
41348 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41349
41350 wxPyEndAllowThreads(__tstate);
41351 if (PyErr_Occurred()) SWIG_fail;
41352 }
41353 {
41354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41355 }
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41363 PyObject *resultobj = NULL;
41364 wxSizer *arg1 = (wxSizer *) 0 ;
41365 PyObject *arg2 = (PyObject *) 0 ;
41366 bool result;
41367 PyObject * obj0 = 0 ;
41368 PyObject * obj1 = 0 ;
41369 char *kwnames[] = {
41370 (char *) "self",(char *) "item", NULL
41371 };
41372
41373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41375 if (SWIG_arg_fail(1)) SWIG_fail;
41376 arg2 = obj1;
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 result = (bool)wxSizer_IsShown(arg1,arg2);
41380
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 {
41385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj = NULL;
41395 wxSizer *arg1 = (wxSizer *) 0 ;
41396 bool arg2 ;
41397 PyObject * obj0 = 0 ;
41398 PyObject * obj1 = 0 ;
41399 char *kwnames[] = {
41400 (char *) "self",(char *) "show", NULL
41401 };
41402
41403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41405 if (SWIG_arg_fail(1)) SWIG_fail;
41406 {
41407 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41408 if (SWIG_arg_fail(2)) SWIG_fail;
41409 }
41410 {
41411 PyThreadState* __tstate = wxPyBeginAllowThreads();
41412 (arg1)->ShowItems(arg2);
41413
41414 wxPyEndAllowThreads(__tstate);
41415 if (PyErr_Occurred()) SWIG_fail;
41416 }
41417 Py_INCREF(Py_None); resultobj = Py_None;
41418 return resultobj;
41419 fail:
41420 return NULL;
41421 }
41422
41423
41424 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41425 PyObject *obj;
41426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41427 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41428 Py_INCREF(obj);
41429 return Py_BuildValue((char *)"");
41430 }
41431 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj = NULL;
41433 wxPySizer *result;
41434 char *kwnames[] = {
41435 NULL
41436 };
41437
41438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 result = (wxPySizer *)new wxPySizer();
41442
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41447 return resultobj;
41448 fail:
41449 return NULL;
41450 }
41451
41452
41453 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41454 PyObject *resultobj = NULL;
41455 wxPySizer *arg1 = (wxPySizer *) 0 ;
41456 PyObject *arg2 = (PyObject *) 0 ;
41457 PyObject *arg3 = (PyObject *) 0 ;
41458 PyObject * obj0 = 0 ;
41459 PyObject * obj1 = 0 ;
41460 PyObject * obj2 = 0 ;
41461 char *kwnames[] = {
41462 (char *) "self",(char *) "self",(char *) "_class", NULL
41463 };
41464
41465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41467 if (SWIG_arg_fail(1)) SWIG_fail;
41468 arg2 = obj1;
41469 arg3 = obj2;
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 (arg1)->_setCallbackInfo(arg2,arg3);
41473
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 Py_INCREF(Py_None); resultobj = Py_None;
41478 return resultobj;
41479 fail:
41480 return NULL;
41481 }
41482
41483
41484 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41485 PyObject *obj;
41486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41487 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41488 Py_INCREF(obj);
41489 return Py_BuildValue((char *)"");
41490 }
41491 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41492 PyObject *resultobj = NULL;
41493 int arg1 = (int) wxHORIZONTAL ;
41494 wxBoxSizer *result;
41495 PyObject * obj0 = 0 ;
41496 char *kwnames[] = {
41497 (char *) "orient", NULL
41498 };
41499
41500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41501 if (obj0) {
41502 {
41503 arg1 = static_cast<int >(SWIG_As_int(obj0));
41504 if (SWIG_arg_fail(1)) SWIG_fail;
41505 }
41506 }
41507 {
41508 PyThreadState* __tstate = wxPyBeginAllowThreads();
41509 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41510
41511 wxPyEndAllowThreads(__tstate);
41512 if (PyErr_Occurred()) SWIG_fail;
41513 }
41514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41515 return resultobj;
41516 fail:
41517 return NULL;
41518 }
41519
41520
41521 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41522 PyObject *resultobj = NULL;
41523 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41524 int result;
41525 PyObject * obj0 = 0 ;
41526 char *kwnames[] = {
41527 (char *) "self", NULL
41528 };
41529
41530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41532 if (SWIG_arg_fail(1)) SWIG_fail;
41533 {
41534 PyThreadState* __tstate = wxPyBeginAllowThreads();
41535 result = (int)(arg1)->GetOrientation();
41536
41537 wxPyEndAllowThreads(__tstate);
41538 if (PyErr_Occurred()) SWIG_fail;
41539 }
41540 {
41541 resultobj = SWIG_From_int(static_cast<int >(result));
41542 }
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41550 PyObject *resultobj = NULL;
41551 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41552 int arg2 ;
41553 PyObject * obj0 = 0 ;
41554 PyObject * obj1 = 0 ;
41555 char *kwnames[] = {
41556 (char *) "self",(char *) "orient", NULL
41557 };
41558
41559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41561 if (SWIG_arg_fail(1)) SWIG_fail;
41562 {
41563 arg2 = static_cast<int >(SWIG_As_int(obj1));
41564 if (SWIG_arg_fail(2)) SWIG_fail;
41565 }
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 (arg1)->SetOrientation(arg2);
41569
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 Py_INCREF(Py_None); resultobj = Py_None;
41574 return resultobj;
41575 fail:
41576 return NULL;
41577 }
41578
41579
41580 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41581 PyObject *obj;
41582 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41583 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41584 Py_INCREF(obj);
41585 return Py_BuildValue((char *)"");
41586 }
41587 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41588 PyObject *resultobj = NULL;
41589 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41590 int arg2 = (int) wxHORIZONTAL ;
41591 wxStaticBoxSizer *result;
41592 PyObject * obj0 = 0 ;
41593 PyObject * obj1 = 0 ;
41594 char *kwnames[] = {
41595 (char *) "box",(char *) "orient", NULL
41596 };
41597
41598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41600 if (SWIG_arg_fail(1)) SWIG_fail;
41601 if (obj1) {
41602 {
41603 arg2 = static_cast<int >(SWIG_As_int(obj1));
41604 if (SWIG_arg_fail(2)) SWIG_fail;
41605 }
41606 }
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41610
41611 wxPyEndAllowThreads(__tstate);
41612 if (PyErr_Occurred()) SWIG_fail;
41613 }
41614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41615 return resultobj;
41616 fail:
41617 return NULL;
41618 }
41619
41620
41621 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41622 PyObject *resultobj = NULL;
41623 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41624 wxStaticBox *result;
41625 PyObject * obj0 = 0 ;
41626 char *kwnames[] = {
41627 (char *) "self", NULL
41628 };
41629
41630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41632 if (SWIG_arg_fail(1)) SWIG_fail;
41633 {
41634 PyThreadState* __tstate = wxPyBeginAllowThreads();
41635 result = (wxStaticBox *)(arg1)->GetStaticBox();
41636
41637 wxPyEndAllowThreads(__tstate);
41638 if (PyErr_Occurred()) SWIG_fail;
41639 }
41640 {
41641 resultobj = wxPyMake_wxObject(result, 0);
41642 }
41643 return resultobj;
41644 fail:
41645 return NULL;
41646 }
41647
41648
41649 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41650 PyObject *obj;
41651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41652 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41653 Py_INCREF(obj);
41654 return Py_BuildValue((char *)"");
41655 }
41656 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj = NULL;
41658 int arg1 = (int) 1 ;
41659 int arg2 = (int) 0 ;
41660 int arg3 = (int) 0 ;
41661 int arg4 = (int) 0 ;
41662 wxGridSizer *result;
41663 PyObject * obj0 = 0 ;
41664 PyObject * obj1 = 0 ;
41665 PyObject * obj2 = 0 ;
41666 PyObject * obj3 = 0 ;
41667 char *kwnames[] = {
41668 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41669 };
41670
41671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41672 if (obj0) {
41673 {
41674 arg1 = static_cast<int >(SWIG_As_int(obj0));
41675 if (SWIG_arg_fail(1)) SWIG_fail;
41676 }
41677 }
41678 if (obj1) {
41679 {
41680 arg2 = static_cast<int >(SWIG_As_int(obj1));
41681 if (SWIG_arg_fail(2)) SWIG_fail;
41682 }
41683 }
41684 if (obj2) {
41685 {
41686 arg3 = static_cast<int >(SWIG_As_int(obj2));
41687 if (SWIG_arg_fail(3)) SWIG_fail;
41688 }
41689 }
41690 if (obj3) {
41691 {
41692 arg4 = static_cast<int >(SWIG_As_int(obj3));
41693 if (SWIG_arg_fail(4)) SWIG_fail;
41694 }
41695 }
41696 {
41697 PyThreadState* __tstate = wxPyBeginAllowThreads();
41698 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41699
41700 wxPyEndAllowThreads(__tstate);
41701 if (PyErr_Occurred()) SWIG_fail;
41702 }
41703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41704 return resultobj;
41705 fail:
41706 return NULL;
41707 }
41708
41709
41710 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41711 PyObject *resultobj = NULL;
41712 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41713 int arg2 ;
41714 PyObject * obj0 = 0 ;
41715 PyObject * obj1 = 0 ;
41716 char *kwnames[] = {
41717 (char *) "self",(char *) "cols", NULL
41718 };
41719
41720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41722 if (SWIG_arg_fail(1)) SWIG_fail;
41723 {
41724 arg2 = static_cast<int >(SWIG_As_int(obj1));
41725 if (SWIG_arg_fail(2)) SWIG_fail;
41726 }
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 (arg1)->SetCols(arg2);
41730
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 Py_INCREF(Py_None); resultobj = Py_None;
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = NULL;
41743 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41744 int arg2 ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 char *kwnames[] = {
41748 (char *) "self",(char *) "rows", NULL
41749 };
41750
41751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41753 if (SWIG_arg_fail(1)) SWIG_fail;
41754 {
41755 arg2 = static_cast<int >(SWIG_As_int(obj1));
41756 if (SWIG_arg_fail(2)) SWIG_fail;
41757 }
41758 {
41759 PyThreadState* __tstate = wxPyBeginAllowThreads();
41760 (arg1)->SetRows(arg2);
41761
41762 wxPyEndAllowThreads(__tstate);
41763 if (PyErr_Occurred()) SWIG_fail;
41764 }
41765 Py_INCREF(Py_None); resultobj = Py_None;
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41773 PyObject *resultobj = NULL;
41774 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41775 int arg2 ;
41776 PyObject * obj0 = 0 ;
41777 PyObject * obj1 = 0 ;
41778 char *kwnames[] = {
41779 (char *) "self",(char *) "gap", NULL
41780 };
41781
41782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41784 if (SWIG_arg_fail(1)) SWIG_fail;
41785 {
41786 arg2 = static_cast<int >(SWIG_As_int(obj1));
41787 if (SWIG_arg_fail(2)) SWIG_fail;
41788 }
41789 {
41790 PyThreadState* __tstate = wxPyBeginAllowThreads();
41791 (arg1)->SetVGap(arg2);
41792
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 Py_INCREF(Py_None); resultobj = Py_None;
41797 return resultobj;
41798 fail:
41799 return NULL;
41800 }
41801
41802
41803 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41804 PyObject *resultobj = NULL;
41805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41806 int arg2 ;
41807 PyObject * obj0 = 0 ;
41808 PyObject * obj1 = 0 ;
41809 char *kwnames[] = {
41810 (char *) "self",(char *) "gap", NULL
41811 };
41812
41813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41815 if (SWIG_arg_fail(1)) SWIG_fail;
41816 {
41817 arg2 = static_cast<int >(SWIG_As_int(obj1));
41818 if (SWIG_arg_fail(2)) SWIG_fail;
41819 }
41820 {
41821 PyThreadState* __tstate = wxPyBeginAllowThreads();
41822 (arg1)->SetHGap(arg2);
41823
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 Py_INCREF(Py_None); resultobj = Py_None;
41828 return resultobj;
41829 fail:
41830 return NULL;
41831 }
41832
41833
41834 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41835 PyObject *resultobj = NULL;
41836 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41837 int result;
41838 PyObject * obj0 = 0 ;
41839 char *kwnames[] = {
41840 (char *) "self", NULL
41841 };
41842
41843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41845 if (SWIG_arg_fail(1)) SWIG_fail;
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 result = (int)(arg1)->GetCols();
41849
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 {
41854 resultobj = SWIG_From_int(static_cast<int >(result));
41855 }
41856 return resultobj;
41857 fail:
41858 return NULL;
41859 }
41860
41861
41862 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41863 PyObject *resultobj = NULL;
41864 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41865 int result;
41866 PyObject * obj0 = 0 ;
41867 char *kwnames[] = {
41868 (char *) "self", NULL
41869 };
41870
41871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41873 if (SWIG_arg_fail(1)) SWIG_fail;
41874 {
41875 PyThreadState* __tstate = wxPyBeginAllowThreads();
41876 result = (int)(arg1)->GetRows();
41877
41878 wxPyEndAllowThreads(__tstate);
41879 if (PyErr_Occurred()) SWIG_fail;
41880 }
41881 {
41882 resultobj = SWIG_From_int(static_cast<int >(result));
41883 }
41884 return resultobj;
41885 fail:
41886 return NULL;
41887 }
41888
41889
41890 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41891 PyObject *resultobj = NULL;
41892 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41893 int result;
41894 PyObject * obj0 = 0 ;
41895 char *kwnames[] = {
41896 (char *) "self", NULL
41897 };
41898
41899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41901 if (SWIG_arg_fail(1)) SWIG_fail;
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 result = (int)(arg1)->GetVGap();
41905
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 {
41910 resultobj = SWIG_From_int(static_cast<int >(result));
41911 }
41912 return resultobj;
41913 fail:
41914 return NULL;
41915 }
41916
41917
41918 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41919 PyObject *resultobj = NULL;
41920 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41921 int result;
41922 PyObject * obj0 = 0 ;
41923 char *kwnames[] = {
41924 (char *) "self", NULL
41925 };
41926
41927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41929 if (SWIG_arg_fail(1)) SWIG_fail;
41930 {
41931 PyThreadState* __tstate = wxPyBeginAllowThreads();
41932 result = (int)(arg1)->GetHGap();
41933
41934 wxPyEndAllowThreads(__tstate);
41935 if (PyErr_Occurred()) SWIG_fail;
41936 }
41937 {
41938 resultobj = SWIG_From_int(static_cast<int >(result));
41939 }
41940 return resultobj;
41941 fail:
41942 return NULL;
41943 }
41944
41945
41946 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41947 PyObject *obj;
41948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41949 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41950 Py_INCREF(obj);
41951 return Py_BuildValue((char *)"");
41952 }
41953 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41954 PyObject *resultobj = NULL;
41955 int arg1 = (int) 1 ;
41956 int arg2 = (int) 0 ;
41957 int arg3 = (int) 0 ;
41958 int arg4 = (int) 0 ;
41959 wxFlexGridSizer *result;
41960 PyObject * obj0 = 0 ;
41961 PyObject * obj1 = 0 ;
41962 PyObject * obj2 = 0 ;
41963 PyObject * obj3 = 0 ;
41964 char *kwnames[] = {
41965 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41966 };
41967
41968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41969 if (obj0) {
41970 {
41971 arg1 = static_cast<int >(SWIG_As_int(obj0));
41972 if (SWIG_arg_fail(1)) SWIG_fail;
41973 }
41974 }
41975 if (obj1) {
41976 {
41977 arg2 = static_cast<int >(SWIG_As_int(obj1));
41978 if (SWIG_arg_fail(2)) SWIG_fail;
41979 }
41980 }
41981 if (obj2) {
41982 {
41983 arg3 = static_cast<int >(SWIG_As_int(obj2));
41984 if (SWIG_arg_fail(3)) SWIG_fail;
41985 }
41986 }
41987 if (obj3) {
41988 {
41989 arg4 = static_cast<int >(SWIG_As_int(obj3));
41990 if (SWIG_arg_fail(4)) SWIG_fail;
41991 }
41992 }
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41996
41997 wxPyEndAllowThreads(__tstate);
41998 if (PyErr_Occurred()) SWIG_fail;
41999 }
42000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42001 return resultobj;
42002 fail:
42003 return NULL;
42004 }
42005
42006
42007 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42008 PyObject *resultobj = NULL;
42009 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42010 size_t arg2 ;
42011 int arg3 = (int) 0 ;
42012 PyObject * obj0 = 0 ;
42013 PyObject * obj1 = 0 ;
42014 PyObject * obj2 = 0 ;
42015 char *kwnames[] = {
42016 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42017 };
42018
42019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42021 if (SWIG_arg_fail(1)) SWIG_fail;
42022 {
42023 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42024 if (SWIG_arg_fail(2)) SWIG_fail;
42025 }
42026 if (obj2) {
42027 {
42028 arg3 = static_cast<int >(SWIG_As_int(obj2));
42029 if (SWIG_arg_fail(3)) SWIG_fail;
42030 }
42031 }
42032 {
42033 PyThreadState* __tstate = wxPyBeginAllowThreads();
42034 (arg1)->AddGrowableRow(arg2,arg3);
42035
42036 wxPyEndAllowThreads(__tstate);
42037 if (PyErr_Occurred()) SWIG_fail;
42038 }
42039 Py_INCREF(Py_None); resultobj = Py_None;
42040 return resultobj;
42041 fail:
42042 return NULL;
42043 }
42044
42045
42046 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42047 PyObject *resultobj = NULL;
42048 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42049 size_t arg2 ;
42050 PyObject * obj0 = 0 ;
42051 PyObject * obj1 = 0 ;
42052 char *kwnames[] = {
42053 (char *) "self",(char *) "idx", NULL
42054 };
42055
42056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42058 if (SWIG_arg_fail(1)) SWIG_fail;
42059 {
42060 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42061 if (SWIG_arg_fail(2)) SWIG_fail;
42062 }
42063 {
42064 PyThreadState* __tstate = wxPyBeginAllowThreads();
42065 (arg1)->RemoveGrowableRow(arg2);
42066
42067 wxPyEndAllowThreads(__tstate);
42068 if (PyErr_Occurred()) SWIG_fail;
42069 }
42070 Py_INCREF(Py_None); resultobj = Py_None;
42071 return resultobj;
42072 fail:
42073 return NULL;
42074 }
42075
42076
42077 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42078 PyObject *resultobj = NULL;
42079 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42080 size_t arg2 ;
42081 int arg3 = (int) 0 ;
42082 PyObject * obj0 = 0 ;
42083 PyObject * obj1 = 0 ;
42084 PyObject * obj2 = 0 ;
42085 char *kwnames[] = {
42086 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42087 };
42088
42089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42091 if (SWIG_arg_fail(1)) SWIG_fail;
42092 {
42093 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42094 if (SWIG_arg_fail(2)) SWIG_fail;
42095 }
42096 if (obj2) {
42097 {
42098 arg3 = static_cast<int >(SWIG_As_int(obj2));
42099 if (SWIG_arg_fail(3)) SWIG_fail;
42100 }
42101 }
42102 {
42103 PyThreadState* __tstate = wxPyBeginAllowThreads();
42104 (arg1)->AddGrowableCol(arg2,arg3);
42105
42106 wxPyEndAllowThreads(__tstate);
42107 if (PyErr_Occurred()) SWIG_fail;
42108 }
42109 Py_INCREF(Py_None); resultobj = Py_None;
42110 return resultobj;
42111 fail:
42112 return NULL;
42113 }
42114
42115
42116 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42117 PyObject *resultobj = NULL;
42118 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42119 size_t arg2 ;
42120 PyObject * obj0 = 0 ;
42121 PyObject * obj1 = 0 ;
42122 char *kwnames[] = {
42123 (char *) "self",(char *) "idx", NULL
42124 };
42125
42126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42128 if (SWIG_arg_fail(1)) SWIG_fail;
42129 {
42130 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42131 if (SWIG_arg_fail(2)) SWIG_fail;
42132 }
42133 {
42134 PyThreadState* __tstate = wxPyBeginAllowThreads();
42135 (arg1)->RemoveGrowableCol(arg2);
42136
42137 wxPyEndAllowThreads(__tstate);
42138 if (PyErr_Occurred()) SWIG_fail;
42139 }
42140 Py_INCREF(Py_None); resultobj = Py_None;
42141 return resultobj;
42142 fail:
42143 return NULL;
42144 }
42145
42146
42147 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42148 PyObject *resultobj = NULL;
42149 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42150 int arg2 ;
42151 PyObject * obj0 = 0 ;
42152 PyObject * obj1 = 0 ;
42153 char *kwnames[] = {
42154 (char *) "self",(char *) "direction", NULL
42155 };
42156
42157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42159 if (SWIG_arg_fail(1)) SWIG_fail;
42160 {
42161 arg2 = static_cast<int >(SWIG_As_int(obj1));
42162 if (SWIG_arg_fail(2)) SWIG_fail;
42163 }
42164 {
42165 PyThreadState* __tstate = wxPyBeginAllowThreads();
42166 (arg1)->SetFlexibleDirection(arg2);
42167
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 Py_INCREF(Py_None); resultobj = Py_None;
42172 return resultobj;
42173 fail:
42174 return NULL;
42175 }
42176
42177
42178 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42179 PyObject *resultobj = NULL;
42180 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42181 int result;
42182 PyObject * obj0 = 0 ;
42183 char *kwnames[] = {
42184 (char *) "self", NULL
42185 };
42186
42187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42189 if (SWIG_arg_fail(1)) SWIG_fail;
42190 {
42191 PyThreadState* __tstate = wxPyBeginAllowThreads();
42192 result = (int)(arg1)->GetFlexibleDirection();
42193
42194 wxPyEndAllowThreads(__tstate);
42195 if (PyErr_Occurred()) SWIG_fail;
42196 }
42197 {
42198 resultobj = SWIG_From_int(static_cast<int >(result));
42199 }
42200 return resultobj;
42201 fail:
42202 return NULL;
42203 }
42204
42205
42206 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42207 PyObject *resultobj = NULL;
42208 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42209 wxFlexSizerGrowMode arg2 ;
42210 PyObject * obj0 = 0 ;
42211 PyObject * obj1 = 0 ;
42212 char *kwnames[] = {
42213 (char *) "self",(char *) "mode", NULL
42214 };
42215
42216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42218 if (SWIG_arg_fail(1)) SWIG_fail;
42219 {
42220 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42221 if (SWIG_arg_fail(2)) SWIG_fail;
42222 }
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 (arg1)->SetNonFlexibleGrowMode(arg2);
42226
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 Py_INCREF(Py_None); resultobj = Py_None;
42231 return resultobj;
42232 fail:
42233 return NULL;
42234 }
42235
42236
42237 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42238 PyObject *resultobj = NULL;
42239 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42240 wxFlexSizerGrowMode result;
42241 PyObject * obj0 = 0 ;
42242 char *kwnames[] = {
42243 (char *) "self", NULL
42244 };
42245
42246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42248 if (SWIG_arg_fail(1)) SWIG_fail;
42249 {
42250 PyThreadState* __tstate = wxPyBeginAllowThreads();
42251 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42252
42253 wxPyEndAllowThreads(__tstate);
42254 if (PyErr_Occurred()) SWIG_fail;
42255 }
42256 resultobj = SWIG_From_int((result));
42257 return resultobj;
42258 fail:
42259 return NULL;
42260 }
42261
42262
42263 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42264 PyObject *resultobj = NULL;
42265 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42266 wxArrayInt *result;
42267 PyObject * obj0 = 0 ;
42268 char *kwnames[] = {
42269 (char *) "self", NULL
42270 };
42271
42272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42274 if (SWIG_arg_fail(1)) SWIG_fail;
42275 {
42276 PyThreadState* __tstate = wxPyBeginAllowThreads();
42277 {
42278 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42279 result = (wxArrayInt *) &_result_ref;
42280 }
42281
42282 wxPyEndAllowThreads(__tstate);
42283 if (PyErr_Occurred()) SWIG_fail;
42284 }
42285 {
42286 resultobj = PyList_New(0);
42287 size_t idx;
42288 for (idx = 0; idx < result->GetCount(); idx += 1) {
42289 PyObject* val = PyInt_FromLong( result->Item(idx) );
42290 PyList_Append(resultobj, val);
42291 Py_DECREF(val);
42292 }
42293 }
42294 return resultobj;
42295 fail:
42296 return NULL;
42297 }
42298
42299
42300 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42301 PyObject *resultobj = NULL;
42302 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42303 wxArrayInt *result;
42304 PyObject * obj0 = 0 ;
42305 char *kwnames[] = {
42306 (char *) "self", NULL
42307 };
42308
42309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42311 if (SWIG_arg_fail(1)) SWIG_fail;
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 {
42315 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42316 result = (wxArrayInt *) &_result_ref;
42317 }
42318
42319 wxPyEndAllowThreads(__tstate);
42320 if (PyErr_Occurred()) SWIG_fail;
42321 }
42322 {
42323 resultobj = PyList_New(0);
42324 size_t idx;
42325 for (idx = 0; idx < result->GetCount(); idx += 1) {
42326 PyObject* val = PyInt_FromLong( result->Item(idx) );
42327 PyList_Append(resultobj, val);
42328 Py_DECREF(val);
42329 }
42330 }
42331 return resultobj;
42332 fail:
42333 return NULL;
42334 }
42335
42336
42337 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42338 PyObject *obj;
42339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42340 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42341 Py_INCREF(obj);
42342 return Py_BuildValue((char *)"");
42343 }
42344 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42345 PyObject *resultobj = NULL;
42346 wxStdDialogButtonSizer *result;
42347 char *kwnames[] = {
42348 NULL
42349 };
42350
42351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42352 {
42353 PyThreadState* __tstate = wxPyBeginAllowThreads();
42354 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42355
42356 wxPyEndAllowThreads(__tstate);
42357 if (PyErr_Occurred()) SWIG_fail;
42358 }
42359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42360 return resultobj;
42361 fail:
42362 return NULL;
42363 }
42364
42365
42366 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42367 PyObject *resultobj = NULL;
42368 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42369 wxButton *arg2 = (wxButton *) 0 ;
42370 PyObject * obj0 = 0 ;
42371 PyObject * obj1 = 0 ;
42372 char *kwnames[] = {
42373 (char *) "self",(char *) "button", NULL
42374 };
42375
42376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42378 if (SWIG_arg_fail(1)) SWIG_fail;
42379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42380 if (SWIG_arg_fail(2)) SWIG_fail;
42381 {
42382 PyThreadState* __tstate = wxPyBeginAllowThreads();
42383 (arg1)->AddButton(arg2);
42384
42385 wxPyEndAllowThreads(__tstate);
42386 if (PyErr_Occurred()) SWIG_fail;
42387 }
42388 Py_INCREF(Py_None); resultobj = Py_None;
42389 return resultobj;
42390 fail:
42391 return NULL;
42392 }
42393
42394
42395 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42396 PyObject *resultobj = NULL;
42397 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42398 PyObject * obj0 = 0 ;
42399 char *kwnames[] = {
42400 (char *) "self", NULL
42401 };
42402
42403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42405 if (SWIG_arg_fail(1)) SWIG_fail;
42406 {
42407 PyThreadState* __tstate = wxPyBeginAllowThreads();
42408 (arg1)->Realize();
42409
42410 wxPyEndAllowThreads(__tstate);
42411 if (PyErr_Occurred()) SWIG_fail;
42412 }
42413 Py_INCREF(Py_None); resultobj = Py_None;
42414 return resultobj;
42415 fail:
42416 return NULL;
42417 }
42418
42419
42420 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42421 PyObject *resultobj = NULL;
42422 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42423 wxButton *arg2 = (wxButton *) 0 ;
42424 PyObject * obj0 = 0 ;
42425 PyObject * obj1 = 0 ;
42426 char *kwnames[] = {
42427 (char *) "self",(char *) "button", NULL
42428 };
42429
42430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42432 if (SWIG_arg_fail(1)) SWIG_fail;
42433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42434 if (SWIG_arg_fail(2)) SWIG_fail;
42435 {
42436 PyThreadState* __tstate = wxPyBeginAllowThreads();
42437 (arg1)->SetAffirmativeButton(arg2);
42438
42439 wxPyEndAllowThreads(__tstate);
42440 if (PyErr_Occurred()) SWIG_fail;
42441 }
42442 Py_INCREF(Py_None); resultobj = Py_None;
42443 return resultobj;
42444 fail:
42445 return NULL;
42446 }
42447
42448
42449 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42450 PyObject *resultobj = NULL;
42451 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42452 wxButton *arg2 = (wxButton *) 0 ;
42453 PyObject * obj0 = 0 ;
42454 PyObject * obj1 = 0 ;
42455 char *kwnames[] = {
42456 (char *) "self",(char *) "button", NULL
42457 };
42458
42459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42461 if (SWIG_arg_fail(1)) SWIG_fail;
42462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42463 if (SWIG_arg_fail(2)) SWIG_fail;
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 (arg1)->SetNegativeButton(arg2);
42467
42468 wxPyEndAllowThreads(__tstate);
42469 if (PyErr_Occurred()) SWIG_fail;
42470 }
42471 Py_INCREF(Py_None); resultobj = Py_None;
42472 return resultobj;
42473 fail:
42474 return NULL;
42475 }
42476
42477
42478 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42479 PyObject *resultobj = NULL;
42480 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42481 wxButton *arg2 = (wxButton *) 0 ;
42482 PyObject * obj0 = 0 ;
42483 PyObject * obj1 = 0 ;
42484 char *kwnames[] = {
42485 (char *) "self",(char *) "button", NULL
42486 };
42487
42488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42490 if (SWIG_arg_fail(1)) SWIG_fail;
42491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42492 if (SWIG_arg_fail(2)) SWIG_fail;
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 (arg1)->SetCancelButton(arg2);
42496
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 Py_INCREF(Py_None); resultobj = Py_None;
42501 return resultobj;
42502 fail:
42503 return NULL;
42504 }
42505
42506
42507 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42508 PyObject *resultobj = NULL;
42509 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42510 wxButton *result;
42511 PyObject * obj0 = 0 ;
42512 char *kwnames[] = {
42513 (char *) "self", NULL
42514 };
42515
42516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42518 if (SWIG_arg_fail(1)) SWIG_fail;
42519 {
42520 PyThreadState* __tstate = wxPyBeginAllowThreads();
42521 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42522
42523 wxPyEndAllowThreads(__tstate);
42524 if (PyErr_Occurred()) SWIG_fail;
42525 }
42526 {
42527 resultobj = wxPyMake_wxObject(result, 0);
42528 }
42529 return resultobj;
42530 fail:
42531 return NULL;
42532 }
42533
42534
42535 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42536 PyObject *resultobj = NULL;
42537 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42538 wxButton *result;
42539 PyObject * obj0 = 0 ;
42540 char *kwnames[] = {
42541 (char *) "self", NULL
42542 };
42543
42544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42546 if (SWIG_arg_fail(1)) SWIG_fail;
42547 {
42548 PyThreadState* __tstate = wxPyBeginAllowThreads();
42549 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42550
42551 wxPyEndAllowThreads(__tstate);
42552 if (PyErr_Occurred()) SWIG_fail;
42553 }
42554 {
42555 resultobj = wxPyMake_wxObject(result, 0);
42556 }
42557 return resultobj;
42558 fail:
42559 return NULL;
42560 }
42561
42562
42563 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42564 PyObject *resultobj = NULL;
42565 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42566 wxButton *result;
42567 PyObject * obj0 = 0 ;
42568 char *kwnames[] = {
42569 (char *) "self", NULL
42570 };
42571
42572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42574 if (SWIG_arg_fail(1)) SWIG_fail;
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42578
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 resultobj = wxPyMake_wxObject(result, 0);
42584 }
42585 return resultobj;
42586 fail:
42587 return NULL;
42588 }
42589
42590
42591 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42592 PyObject *resultobj = NULL;
42593 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42594 wxButton *result;
42595 PyObject * obj0 = 0 ;
42596 char *kwnames[] = {
42597 (char *) "self", NULL
42598 };
42599
42600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42602 if (SWIG_arg_fail(1)) SWIG_fail;
42603 {
42604 PyThreadState* __tstate = wxPyBeginAllowThreads();
42605 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42606
42607 wxPyEndAllowThreads(__tstate);
42608 if (PyErr_Occurred()) SWIG_fail;
42609 }
42610 {
42611 resultobj = wxPyMake_wxObject(result, 0);
42612 }
42613 return resultobj;
42614 fail:
42615 return NULL;
42616 }
42617
42618
42619 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42620 PyObject *resultobj = NULL;
42621 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42622 wxButton *result;
42623 PyObject * obj0 = 0 ;
42624 char *kwnames[] = {
42625 (char *) "self", NULL
42626 };
42627
42628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42630 if (SWIG_arg_fail(1)) SWIG_fail;
42631 {
42632 PyThreadState* __tstate = wxPyBeginAllowThreads();
42633 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42634
42635 wxPyEndAllowThreads(__tstate);
42636 if (PyErr_Occurred()) SWIG_fail;
42637 }
42638 {
42639 resultobj = wxPyMake_wxObject(result, 0);
42640 }
42641 return resultobj;
42642 fail:
42643 return NULL;
42644 }
42645
42646
42647 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42648 PyObject *obj;
42649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42650 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42651 Py_INCREF(obj);
42652 return Py_BuildValue((char *)"");
42653 }
42654 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42655 PyObject *resultobj = NULL;
42656 int arg1 = (int) 0 ;
42657 int arg2 = (int) 0 ;
42658 wxGBPosition *result;
42659 PyObject * obj0 = 0 ;
42660 PyObject * obj1 = 0 ;
42661 char *kwnames[] = {
42662 (char *) "row",(char *) "col", NULL
42663 };
42664
42665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42666 if (obj0) {
42667 {
42668 arg1 = static_cast<int >(SWIG_As_int(obj0));
42669 if (SWIG_arg_fail(1)) SWIG_fail;
42670 }
42671 }
42672 if (obj1) {
42673 {
42674 arg2 = static_cast<int >(SWIG_As_int(obj1));
42675 if (SWIG_arg_fail(2)) SWIG_fail;
42676 }
42677 }
42678 {
42679 PyThreadState* __tstate = wxPyBeginAllowThreads();
42680 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42681
42682 wxPyEndAllowThreads(__tstate);
42683 if (PyErr_Occurred()) SWIG_fail;
42684 }
42685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42686 return resultobj;
42687 fail:
42688 return NULL;
42689 }
42690
42691
42692 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42693 PyObject *resultobj = NULL;
42694 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42695 int result;
42696 PyObject * obj0 = 0 ;
42697 char *kwnames[] = {
42698 (char *) "self", NULL
42699 };
42700
42701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42703 if (SWIG_arg_fail(1)) SWIG_fail;
42704 {
42705 PyThreadState* __tstate = wxPyBeginAllowThreads();
42706 result = (int)((wxGBPosition const *)arg1)->GetRow();
42707
42708 wxPyEndAllowThreads(__tstate);
42709 if (PyErr_Occurred()) SWIG_fail;
42710 }
42711 {
42712 resultobj = SWIG_From_int(static_cast<int >(result));
42713 }
42714 return resultobj;
42715 fail:
42716 return NULL;
42717 }
42718
42719
42720 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42721 PyObject *resultobj = NULL;
42722 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42723 int result;
42724 PyObject * obj0 = 0 ;
42725 char *kwnames[] = {
42726 (char *) "self", NULL
42727 };
42728
42729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42731 if (SWIG_arg_fail(1)) SWIG_fail;
42732 {
42733 PyThreadState* __tstate = wxPyBeginAllowThreads();
42734 result = (int)((wxGBPosition const *)arg1)->GetCol();
42735
42736 wxPyEndAllowThreads(__tstate);
42737 if (PyErr_Occurred()) SWIG_fail;
42738 }
42739 {
42740 resultobj = SWIG_From_int(static_cast<int >(result));
42741 }
42742 return resultobj;
42743 fail:
42744 return NULL;
42745 }
42746
42747
42748 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42749 PyObject *resultobj = NULL;
42750 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42751 int arg2 ;
42752 PyObject * obj0 = 0 ;
42753 PyObject * obj1 = 0 ;
42754 char *kwnames[] = {
42755 (char *) "self",(char *) "row", NULL
42756 };
42757
42758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42760 if (SWIG_arg_fail(1)) SWIG_fail;
42761 {
42762 arg2 = static_cast<int >(SWIG_As_int(obj1));
42763 if (SWIG_arg_fail(2)) SWIG_fail;
42764 }
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 (arg1)->SetRow(arg2);
42768
42769 wxPyEndAllowThreads(__tstate);
42770 if (PyErr_Occurred()) SWIG_fail;
42771 }
42772 Py_INCREF(Py_None); resultobj = Py_None;
42773 return resultobj;
42774 fail:
42775 return NULL;
42776 }
42777
42778
42779 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42780 PyObject *resultobj = NULL;
42781 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42782 int arg2 ;
42783 PyObject * obj0 = 0 ;
42784 PyObject * obj1 = 0 ;
42785 char *kwnames[] = {
42786 (char *) "self",(char *) "col", NULL
42787 };
42788
42789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42791 if (SWIG_arg_fail(1)) SWIG_fail;
42792 {
42793 arg2 = static_cast<int >(SWIG_As_int(obj1));
42794 if (SWIG_arg_fail(2)) SWIG_fail;
42795 }
42796 {
42797 PyThreadState* __tstate = wxPyBeginAllowThreads();
42798 (arg1)->SetCol(arg2);
42799
42800 wxPyEndAllowThreads(__tstate);
42801 if (PyErr_Occurred()) SWIG_fail;
42802 }
42803 Py_INCREF(Py_None); resultobj = Py_None;
42804 return resultobj;
42805 fail:
42806 return NULL;
42807 }
42808
42809
42810 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42811 PyObject *resultobj = NULL;
42812 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42813 wxGBPosition *arg2 = 0 ;
42814 bool result;
42815 wxGBPosition temp2 ;
42816 PyObject * obj0 = 0 ;
42817 PyObject * obj1 = 0 ;
42818 char *kwnames[] = {
42819 (char *) "self",(char *) "other", NULL
42820 };
42821
42822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42824 if (SWIG_arg_fail(1)) SWIG_fail;
42825 {
42826 arg2 = &temp2;
42827 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42828 }
42829 {
42830 PyThreadState* __tstate = wxPyBeginAllowThreads();
42831 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42832
42833 wxPyEndAllowThreads(__tstate);
42834 if (PyErr_Occurred()) SWIG_fail;
42835 }
42836 {
42837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42838 }
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42846 PyObject *resultobj = NULL;
42847 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42848 wxGBPosition *arg2 = 0 ;
42849 bool result;
42850 wxGBPosition temp2 ;
42851 PyObject * obj0 = 0 ;
42852 PyObject * obj1 = 0 ;
42853 char *kwnames[] = {
42854 (char *) "self",(char *) "other", NULL
42855 };
42856
42857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(1)) SWIG_fail;
42860 {
42861 arg2 = &temp2;
42862 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42863 }
42864 {
42865 PyThreadState* __tstate = wxPyBeginAllowThreads();
42866 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42867
42868 wxPyEndAllowThreads(__tstate);
42869 if (PyErr_Occurred()) SWIG_fail;
42870 }
42871 {
42872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42873 }
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42881 PyObject *resultobj = NULL;
42882 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42883 int arg2 = (int) 0 ;
42884 int arg3 = (int) 0 ;
42885 PyObject * obj0 = 0 ;
42886 PyObject * obj1 = 0 ;
42887 PyObject * obj2 = 0 ;
42888 char *kwnames[] = {
42889 (char *) "self",(char *) "row",(char *) "col", NULL
42890 };
42891
42892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42894 if (SWIG_arg_fail(1)) SWIG_fail;
42895 if (obj1) {
42896 {
42897 arg2 = static_cast<int >(SWIG_As_int(obj1));
42898 if (SWIG_arg_fail(2)) SWIG_fail;
42899 }
42900 }
42901 if (obj2) {
42902 {
42903 arg3 = static_cast<int >(SWIG_As_int(obj2));
42904 if (SWIG_arg_fail(3)) SWIG_fail;
42905 }
42906 }
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 wxGBPosition_Set(arg1,arg2,arg3);
42910
42911 wxPyEndAllowThreads(__tstate);
42912 if (PyErr_Occurred()) SWIG_fail;
42913 }
42914 Py_INCREF(Py_None); resultobj = Py_None;
42915 return resultobj;
42916 fail:
42917 return NULL;
42918 }
42919
42920
42921 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42922 PyObject *resultobj = NULL;
42923 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42924 PyObject *result;
42925 PyObject * obj0 = 0 ;
42926 char *kwnames[] = {
42927 (char *) "self", NULL
42928 };
42929
42930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42932 if (SWIG_arg_fail(1)) SWIG_fail;
42933 {
42934 PyThreadState* __tstate = wxPyBeginAllowThreads();
42935 result = (PyObject *)wxGBPosition_Get(arg1);
42936
42937 wxPyEndAllowThreads(__tstate);
42938 if (PyErr_Occurred()) SWIG_fail;
42939 }
42940 resultobj = result;
42941 return resultobj;
42942 fail:
42943 return NULL;
42944 }
42945
42946
42947 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42948 PyObject *obj;
42949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42950 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42951 Py_INCREF(obj);
42952 return Py_BuildValue((char *)"");
42953 }
42954 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42955 PyObject *resultobj = NULL;
42956 int arg1 = (int) 1 ;
42957 int arg2 = (int) 1 ;
42958 wxGBSpan *result;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961 char *kwnames[] = {
42962 (char *) "rowspan",(char *) "colspan", NULL
42963 };
42964
42965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42966 if (obj0) {
42967 {
42968 arg1 = static_cast<int >(SWIG_As_int(obj0));
42969 if (SWIG_arg_fail(1)) SWIG_fail;
42970 }
42971 }
42972 if (obj1) {
42973 {
42974 arg2 = static_cast<int >(SWIG_As_int(obj1));
42975 if (SWIG_arg_fail(2)) SWIG_fail;
42976 }
42977 }
42978 {
42979 PyThreadState* __tstate = wxPyBeginAllowThreads();
42980 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42981
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42986 return resultobj;
42987 fail:
42988 return NULL;
42989 }
42990
42991
42992 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj = NULL;
42994 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42995 int result;
42996 PyObject * obj0 = 0 ;
42997 char *kwnames[] = {
42998 (char *) "self", NULL
42999 };
43000
43001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43003 if (SWIG_arg_fail(1)) SWIG_fail;
43004 {
43005 PyThreadState* __tstate = wxPyBeginAllowThreads();
43006 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43007
43008 wxPyEndAllowThreads(__tstate);
43009 if (PyErr_Occurred()) SWIG_fail;
43010 }
43011 {
43012 resultobj = SWIG_From_int(static_cast<int >(result));
43013 }
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj = NULL;
43022 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43023 int result;
43024 PyObject * obj0 = 0 ;
43025 char *kwnames[] = {
43026 (char *) "self", NULL
43027 };
43028
43029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43031 if (SWIG_arg_fail(1)) SWIG_fail;
43032 {
43033 PyThreadState* __tstate = wxPyBeginAllowThreads();
43034 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43035
43036 wxPyEndAllowThreads(__tstate);
43037 if (PyErr_Occurred()) SWIG_fail;
43038 }
43039 {
43040 resultobj = SWIG_From_int(static_cast<int >(result));
43041 }
43042 return resultobj;
43043 fail:
43044 return NULL;
43045 }
43046
43047
43048 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43049 PyObject *resultobj = NULL;
43050 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43051 int arg2 ;
43052 PyObject * obj0 = 0 ;
43053 PyObject * obj1 = 0 ;
43054 char *kwnames[] = {
43055 (char *) "self",(char *) "rowspan", NULL
43056 };
43057
43058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43060 if (SWIG_arg_fail(1)) SWIG_fail;
43061 {
43062 arg2 = static_cast<int >(SWIG_As_int(obj1));
43063 if (SWIG_arg_fail(2)) SWIG_fail;
43064 }
43065 {
43066 PyThreadState* __tstate = wxPyBeginAllowThreads();
43067 (arg1)->SetRowspan(arg2);
43068
43069 wxPyEndAllowThreads(__tstate);
43070 if (PyErr_Occurred()) SWIG_fail;
43071 }
43072 Py_INCREF(Py_None); resultobj = Py_None;
43073 return resultobj;
43074 fail:
43075 return NULL;
43076 }
43077
43078
43079 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43080 PyObject *resultobj = NULL;
43081 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43082 int arg2 ;
43083 PyObject * obj0 = 0 ;
43084 PyObject * obj1 = 0 ;
43085 char *kwnames[] = {
43086 (char *) "self",(char *) "colspan", NULL
43087 };
43088
43089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43091 if (SWIG_arg_fail(1)) SWIG_fail;
43092 {
43093 arg2 = static_cast<int >(SWIG_As_int(obj1));
43094 if (SWIG_arg_fail(2)) SWIG_fail;
43095 }
43096 {
43097 PyThreadState* __tstate = wxPyBeginAllowThreads();
43098 (arg1)->SetColspan(arg2);
43099
43100 wxPyEndAllowThreads(__tstate);
43101 if (PyErr_Occurred()) SWIG_fail;
43102 }
43103 Py_INCREF(Py_None); resultobj = Py_None;
43104 return resultobj;
43105 fail:
43106 return NULL;
43107 }
43108
43109
43110 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43111 PyObject *resultobj = NULL;
43112 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43113 wxGBSpan *arg2 = 0 ;
43114 bool result;
43115 wxGBSpan temp2 ;
43116 PyObject * obj0 = 0 ;
43117 PyObject * obj1 = 0 ;
43118 char *kwnames[] = {
43119 (char *) "self",(char *) "other", NULL
43120 };
43121
43122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43124 if (SWIG_arg_fail(1)) SWIG_fail;
43125 {
43126 arg2 = &temp2;
43127 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43128 }
43129 {
43130 PyThreadState* __tstate = wxPyBeginAllowThreads();
43131 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43132
43133 wxPyEndAllowThreads(__tstate);
43134 if (PyErr_Occurred()) SWIG_fail;
43135 }
43136 {
43137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43138 }
43139 return resultobj;
43140 fail:
43141 return NULL;
43142 }
43143
43144
43145 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43146 PyObject *resultobj = NULL;
43147 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43148 wxGBSpan *arg2 = 0 ;
43149 bool result;
43150 wxGBSpan temp2 ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 char *kwnames[] = {
43154 (char *) "self",(char *) "other", NULL
43155 };
43156
43157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43159 if (SWIG_arg_fail(1)) SWIG_fail;
43160 {
43161 arg2 = &temp2;
43162 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43163 }
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43167
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 {
43172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43173 }
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43181 PyObject *resultobj = NULL;
43182 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43183 int arg2 = (int) 1 ;
43184 int arg3 = (int) 1 ;
43185 PyObject * obj0 = 0 ;
43186 PyObject * obj1 = 0 ;
43187 PyObject * obj2 = 0 ;
43188 char *kwnames[] = {
43189 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43190 };
43191
43192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43194 if (SWIG_arg_fail(1)) SWIG_fail;
43195 if (obj1) {
43196 {
43197 arg2 = static_cast<int >(SWIG_As_int(obj1));
43198 if (SWIG_arg_fail(2)) SWIG_fail;
43199 }
43200 }
43201 if (obj2) {
43202 {
43203 arg3 = static_cast<int >(SWIG_As_int(obj2));
43204 if (SWIG_arg_fail(3)) SWIG_fail;
43205 }
43206 }
43207 {
43208 PyThreadState* __tstate = wxPyBeginAllowThreads();
43209 wxGBSpan_Set(arg1,arg2,arg3);
43210
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 Py_INCREF(Py_None); resultobj = Py_None;
43215 return resultobj;
43216 fail:
43217 return NULL;
43218 }
43219
43220
43221 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43222 PyObject *resultobj = NULL;
43223 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43224 PyObject *result;
43225 PyObject * obj0 = 0 ;
43226 char *kwnames[] = {
43227 (char *) "self", NULL
43228 };
43229
43230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43232 if (SWIG_arg_fail(1)) SWIG_fail;
43233 {
43234 PyThreadState* __tstate = wxPyBeginAllowThreads();
43235 result = (PyObject *)wxGBSpan_Get(arg1);
43236
43237 wxPyEndAllowThreads(__tstate);
43238 if (PyErr_Occurred()) SWIG_fail;
43239 }
43240 resultobj = result;
43241 return resultobj;
43242 fail:
43243 return NULL;
43244 }
43245
43246
43247 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43248 PyObject *obj;
43249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43250 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43251 Py_INCREF(obj);
43252 return Py_BuildValue((char *)"");
43253 }
43254 static int _wrap_DefaultSpan_set(PyObject *) {
43255 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43256 return 1;
43257 }
43258
43259
43260 static PyObject *_wrap_DefaultSpan_get(void) {
43261 PyObject *pyobj = NULL;
43262
43263 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43264 return pyobj;
43265 }
43266
43267
43268 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43269 PyObject *resultobj = NULL;
43270 wxGBSizerItem *result;
43271 char *kwnames[] = {
43272 NULL
43273 };
43274
43275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43276 {
43277 PyThreadState* __tstate = wxPyBeginAllowThreads();
43278 result = (wxGBSizerItem *)new wxGBSizerItem();
43279
43280 wxPyEndAllowThreads(__tstate);
43281 if (PyErr_Occurred()) SWIG_fail;
43282 }
43283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43291 PyObject *resultobj = NULL;
43292 wxWindow *arg1 = (wxWindow *) 0 ;
43293 wxGBPosition *arg2 = 0 ;
43294 wxGBSpan *arg3 = 0 ;
43295 int arg4 ;
43296 int arg5 ;
43297 PyObject *arg6 = (PyObject *) NULL ;
43298 wxGBSizerItem *result;
43299 wxGBPosition temp2 ;
43300 wxGBSpan temp3 ;
43301 PyObject * obj0 = 0 ;
43302 PyObject * obj1 = 0 ;
43303 PyObject * obj2 = 0 ;
43304 PyObject * obj3 = 0 ;
43305 PyObject * obj4 = 0 ;
43306 PyObject * obj5 = 0 ;
43307 char *kwnames[] = {
43308 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43309 };
43310
43311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(1)) SWIG_fail;
43314 {
43315 arg2 = &temp2;
43316 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43317 }
43318 {
43319 arg3 = &temp3;
43320 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43321 }
43322 {
43323 arg4 = static_cast<int >(SWIG_As_int(obj3));
43324 if (SWIG_arg_fail(4)) SWIG_fail;
43325 }
43326 {
43327 arg5 = static_cast<int >(SWIG_As_int(obj4));
43328 if (SWIG_arg_fail(5)) SWIG_fail;
43329 }
43330 if (obj5) {
43331 arg6 = obj5;
43332 }
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43336
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43341 return resultobj;
43342 fail:
43343 return NULL;
43344 }
43345
43346
43347 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43348 PyObject *resultobj = NULL;
43349 wxSizer *arg1 = (wxSizer *) 0 ;
43350 wxGBPosition *arg2 = 0 ;
43351 wxGBSpan *arg3 = 0 ;
43352 int arg4 ;
43353 int arg5 ;
43354 PyObject *arg6 = (PyObject *) NULL ;
43355 wxGBSizerItem *result;
43356 wxGBPosition temp2 ;
43357 wxGBSpan temp3 ;
43358 PyObject * obj0 = 0 ;
43359 PyObject * obj1 = 0 ;
43360 PyObject * obj2 = 0 ;
43361 PyObject * obj3 = 0 ;
43362 PyObject * obj4 = 0 ;
43363 PyObject * obj5 = 0 ;
43364 char *kwnames[] = {
43365 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43366 };
43367
43368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43370 if (SWIG_arg_fail(1)) SWIG_fail;
43371 {
43372 arg2 = &temp2;
43373 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43374 }
43375 {
43376 arg3 = &temp3;
43377 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43378 }
43379 {
43380 arg4 = static_cast<int >(SWIG_As_int(obj3));
43381 if (SWIG_arg_fail(4)) SWIG_fail;
43382 }
43383 {
43384 arg5 = static_cast<int >(SWIG_As_int(obj4));
43385 if (SWIG_arg_fail(5)) SWIG_fail;
43386 }
43387 if (obj5) {
43388 arg6 = obj5;
43389 }
43390 {
43391 PyThreadState* __tstate = wxPyBeginAllowThreads();
43392 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43393
43394 wxPyEndAllowThreads(__tstate);
43395 if (PyErr_Occurred()) SWIG_fail;
43396 }
43397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43398 return resultobj;
43399 fail:
43400 return NULL;
43401 }
43402
43403
43404 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43405 PyObject *resultobj = NULL;
43406 int arg1 ;
43407 int arg2 ;
43408 wxGBPosition *arg3 = 0 ;
43409 wxGBSpan *arg4 = 0 ;
43410 int arg5 ;
43411 int arg6 ;
43412 PyObject *arg7 = (PyObject *) NULL ;
43413 wxGBSizerItem *result;
43414 wxGBPosition temp3 ;
43415 wxGBSpan temp4 ;
43416 PyObject * obj0 = 0 ;
43417 PyObject * obj1 = 0 ;
43418 PyObject * obj2 = 0 ;
43419 PyObject * obj3 = 0 ;
43420 PyObject * obj4 = 0 ;
43421 PyObject * obj5 = 0 ;
43422 PyObject * obj6 = 0 ;
43423 char *kwnames[] = {
43424 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43425 };
43426
43427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43428 {
43429 arg1 = static_cast<int >(SWIG_As_int(obj0));
43430 if (SWIG_arg_fail(1)) SWIG_fail;
43431 }
43432 {
43433 arg2 = static_cast<int >(SWIG_As_int(obj1));
43434 if (SWIG_arg_fail(2)) SWIG_fail;
43435 }
43436 {
43437 arg3 = &temp3;
43438 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43439 }
43440 {
43441 arg4 = &temp4;
43442 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43443 }
43444 {
43445 arg5 = static_cast<int >(SWIG_As_int(obj4));
43446 if (SWIG_arg_fail(5)) SWIG_fail;
43447 }
43448 {
43449 arg6 = static_cast<int >(SWIG_As_int(obj5));
43450 if (SWIG_arg_fail(6)) SWIG_fail;
43451 }
43452 if (obj6) {
43453 arg7 = obj6;
43454 }
43455 {
43456 PyThreadState* __tstate = wxPyBeginAllowThreads();
43457 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43458
43459 wxPyEndAllowThreads(__tstate);
43460 if (PyErr_Occurred()) SWIG_fail;
43461 }
43462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43463 return resultobj;
43464 fail:
43465 return NULL;
43466 }
43467
43468
43469 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43470 PyObject *resultobj = NULL;
43471 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43472 wxGBPosition result;
43473 PyObject * obj0 = 0 ;
43474 char *kwnames[] = {
43475 (char *) "self", NULL
43476 };
43477
43478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43480 if (SWIG_arg_fail(1)) SWIG_fail;
43481 {
43482 PyThreadState* __tstate = wxPyBeginAllowThreads();
43483 result = ((wxGBSizerItem const *)arg1)->GetPos();
43484
43485 wxPyEndAllowThreads(__tstate);
43486 if (PyErr_Occurred()) SWIG_fail;
43487 }
43488 {
43489 wxGBPosition * resultptr;
43490 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43492 }
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43500 PyObject *resultobj = NULL;
43501 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43502 wxGBSpan result;
43503 PyObject * obj0 = 0 ;
43504 char *kwnames[] = {
43505 (char *) "self", NULL
43506 };
43507
43508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43510 if (SWIG_arg_fail(1)) SWIG_fail;
43511 {
43512 PyThreadState* __tstate = wxPyBeginAllowThreads();
43513 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43514
43515 wxPyEndAllowThreads(__tstate);
43516 if (PyErr_Occurred()) SWIG_fail;
43517 }
43518 {
43519 wxGBSpan * resultptr;
43520 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43522 }
43523 return resultobj;
43524 fail:
43525 return NULL;
43526 }
43527
43528
43529 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43530 PyObject *resultobj = NULL;
43531 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43532 wxGBPosition *arg2 = 0 ;
43533 bool result;
43534 wxGBPosition temp2 ;
43535 PyObject * obj0 = 0 ;
43536 PyObject * obj1 = 0 ;
43537 char *kwnames[] = {
43538 (char *) "self",(char *) "pos", NULL
43539 };
43540
43541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43543 if (SWIG_arg_fail(1)) SWIG_fail;
43544 {
43545 arg2 = &temp2;
43546 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43547 }
43548 {
43549 PyThreadState* __tstate = wxPyBeginAllowThreads();
43550 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43551
43552 wxPyEndAllowThreads(__tstate);
43553 if (PyErr_Occurred()) SWIG_fail;
43554 }
43555 {
43556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43557 }
43558 return resultobj;
43559 fail:
43560 return NULL;
43561 }
43562
43563
43564 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43565 PyObject *resultobj = NULL;
43566 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43567 wxGBSpan *arg2 = 0 ;
43568 bool result;
43569 wxGBSpan temp2 ;
43570 PyObject * obj0 = 0 ;
43571 PyObject * obj1 = 0 ;
43572 char *kwnames[] = {
43573 (char *) "self",(char *) "span", NULL
43574 };
43575
43576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43578 if (SWIG_arg_fail(1)) SWIG_fail;
43579 {
43580 arg2 = &temp2;
43581 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43582 }
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43586
43587 wxPyEndAllowThreads(__tstate);
43588 if (PyErr_Occurred()) SWIG_fail;
43589 }
43590 {
43591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43592 }
43593 return resultobj;
43594 fail:
43595 return NULL;
43596 }
43597
43598
43599 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43600 PyObject *resultobj = NULL;
43601 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43602 wxGBSizerItem *arg2 = 0 ;
43603 bool result;
43604 PyObject * obj0 = 0 ;
43605 PyObject * obj1 = 0 ;
43606 char *kwnames[] = {
43607 (char *) "self",(char *) "other", NULL
43608 };
43609
43610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43612 if (SWIG_arg_fail(1)) SWIG_fail;
43613 {
43614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43615 if (SWIG_arg_fail(2)) SWIG_fail;
43616 if (arg2 == NULL) {
43617 SWIG_null_ref("wxGBSizerItem");
43618 }
43619 if (SWIG_arg_fail(2)) SWIG_fail;
43620 }
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43624
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 {
43629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43630 }
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj = NULL;
43639 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43640 wxGBPosition *arg2 = 0 ;
43641 wxGBSpan *arg3 = 0 ;
43642 bool result;
43643 wxGBPosition temp2 ;
43644 wxGBSpan temp3 ;
43645 PyObject * obj0 = 0 ;
43646 PyObject * obj1 = 0 ;
43647 PyObject * obj2 = 0 ;
43648 char *kwnames[] = {
43649 (char *) "self",(char *) "pos",(char *) "span", NULL
43650 };
43651
43652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43654 if (SWIG_arg_fail(1)) SWIG_fail;
43655 {
43656 arg2 = &temp2;
43657 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43658 }
43659 {
43660 arg3 = &temp3;
43661 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43662 }
43663 {
43664 PyThreadState* __tstate = wxPyBeginAllowThreads();
43665 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43666
43667 wxPyEndAllowThreads(__tstate);
43668 if (PyErr_Occurred()) SWIG_fail;
43669 }
43670 {
43671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43672 }
43673 return resultobj;
43674 fail:
43675 return NULL;
43676 }
43677
43678
43679 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43680 PyObject *resultobj = NULL;
43681 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43682 wxGBPosition result;
43683 PyObject * obj0 = 0 ;
43684 char *kwnames[] = {
43685 (char *) "self", NULL
43686 };
43687
43688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43690 if (SWIG_arg_fail(1)) SWIG_fail;
43691 {
43692 PyThreadState* __tstate = wxPyBeginAllowThreads();
43693 result = wxGBSizerItem_GetEndPos(arg1);
43694
43695 wxPyEndAllowThreads(__tstate);
43696 if (PyErr_Occurred()) SWIG_fail;
43697 }
43698 {
43699 wxGBPosition * resultptr;
43700 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43701 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43702 }
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43710 PyObject *resultobj = NULL;
43711 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43712 wxGridBagSizer *result;
43713 PyObject * obj0 = 0 ;
43714 char *kwnames[] = {
43715 (char *) "self", NULL
43716 };
43717
43718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43720 if (SWIG_arg_fail(1)) SWIG_fail;
43721 {
43722 PyThreadState* __tstate = wxPyBeginAllowThreads();
43723 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43724
43725 wxPyEndAllowThreads(__tstate);
43726 if (PyErr_Occurred()) SWIG_fail;
43727 }
43728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43729 return resultobj;
43730 fail:
43731 return NULL;
43732 }
43733
43734
43735 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43736 PyObject *resultobj = NULL;
43737 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43738 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43739 PyObject * obj0 = 0 ;
43740 PyObject * obj1 = 0 ;
43741 char *kwnames[] = {
43742 (char *) "self",(char *) "sizer", NULL
43743 };
43744
43745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43747 if (SWIG_arg_fail(1)) SWIG_fail;
43748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43749 if (SWIG_arg_fail(2)) SWIG_fail;
43750 {
43751 PyThreadState* __tstate = wxPyBeginAllowThreads();
43752 (arg1)->SetGBSizer(arg2);
43753
43754 wxPyEndAllowThreads(__tstate);
43755 if (PyErr_Occurred()) SWIG_fail;
43756 }
43757 Py_INCREF(Py_None); resultobj = Py_None;
43758 return resultobj;
43759 fail:
43760 return NULL;
43761 }
43762
43763
43764 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43765 PyObject *obj;
43766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43767 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43768 Py_INCREF(obj);
43769 return Py_BuildValue((char *)"");
43770 }
43771 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43772 PyObject *resultobj = NULL;
43773 int arg1 = (int) 0 ;
43774 int arg2 = (int) 0 ;
43775 wxGridBagSizer *result;
43776 PyObject * obj0 = 0 ;
43777 PyObject * obj1 = 0 ;
43778 char *kwnames[] = {
43779 (char *) "vgap",(char *) "hgap", NULL
43780 };
43781
43782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43783 if (obj0) {
43784 {
43785 arg1 = static_cast<int >(SWIG_As_int(obj0));
43786 if (SWIG_arg_fail(1)) SWIG_fail;
43787 }
43788 }
43789 if (obj1) {
43790 {
43791 arg2 = static_cast<int >(SWIG_As_int(obj1));
43792 if (SWIG_arg_fail(2)) SWIG_fail;
43793 }
43794 }
43795 {
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43798
43799 wxPyEndAllowThreads(__tstate);
43800 if (PyErr_Occurred()) SWIG_fail;
43801 }
43802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43810 PyObject *resultobj = NULL;
43811 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43812 PyObject *arg2 = (PyObject *) 0 ;
43813 wxGBPosition *arg3 = 0 ;
43814 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43815 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43816 int arg5 = (int) 0 ;
43817 int arg6 = (int) 0 ;
43818 PyObject *arg7 = (PyObject *) NULL ;
43819 wxGBSizerItem *result;
43820 wxGBPosition temp3 ;
43821 wxGBSpan temp4 ;
43822 PyObject * obj0 = 0 ;
43823 PyObject * obj1 = 0 ;
43824 PyObject * obj2 = 0 ;
43825 PyObject * obj3 = 0 ;
43826 PyObject * obj4 = 0 ;
43827 PyObject * obj5 = 0 ;
43828 PyObject * obj6 = 0 ;
43829 char *kwnames[] = {
43830 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43831 };
43832
43833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43835 if (SWIG_arg_fail(1)) SWIG_fail;
43836 arg2 = obj1;
43837 {
43838 arg3 = &temp3;
43839 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43840 }
43841 if (obj3) {
43842 {
43843 arg4 = &temp4;
43844 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43845 }
43846 }
43847 if (obj4) {
43848 {
43849 arg5 = static_cast<int >(SWIG_As_int(obj4));
43850 if (SWIG_arg_fail(5)) SWIG_fail;
43851 }
43852 }
43853 if (obj5) {
43854 {
43855 arg6 = static_cast<int >(SWIG_As_int(obj5));
43856 if (SWIG_arg_fail(6)) SWIG_fail;
43857 }
43858 }
43859 if (obj6) {
43860 arg7 = obj6;
43861 }
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43865
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43870 return resultobj;
43871 fail:
43872 return NULL;
43873 }
43874
43875
43876 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43877 PyObject *resultobj = NULL;
43878 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43879 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43880 wxGBSizerItem *result;
43881 PyObject * obj0 = 0 ;
43882 PyObject * obj1 = 0 ;
43883 char *kwnames[] = {
43884 (char *) "self",(char *) "item", NULL
43885 };
43886
43887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43889 if (SWIG_arg_fail(1)) SWIG_fail;
43890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43891 if (SWIG_arg_fail(2)) SWIG_fail;
43892 {
43893 PyThreadState* __tstate = wxPyBeginAllowThreads();
43894 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43895
43896 wxPyEndAllowThreads(__tstate);
43897 if (PyErr_Occurred()) SWIG_fail;
43898 }
43899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43900 return resultobj;
43901 fail:
43902 return NULL;
43903 }
43904
43905
43906 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43907 PyObject *resultobj = NULL;
43908 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43909 int arg2 ;
43910 int arg3 ;
43911 wxSize result;
43912 PyObject * obj0 = 0 ;
43913 PyObject * obj1 = 0 ;
43914 PyObject * obj2 = 0 ;
43915 char *kwnames[] = {
43916 (char *) "self",(char *) "row",(char *) "col", NULL
43917 };
43918
43919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43921 if (SWIG_arg_fail(1)) SWIG_fail;
43922 {
43923 arg2 = static_cast<int >(SWIG_As_int(obj1));
43924 if (SWIG_arg_fail(2)) SWIG_fail;
43925 }
43926 {
43927 arg3 = static_cast<int >(SWIG_As_int(obj2));
43928 if (SWIG_arg_fail(3)) SWIG_fail;
43929 }
43930 {
43931 PyThreadState* __tstate = wxPyBeginAllowThreads();
43932 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43933
43934 wxPyEndAllowThreads(__tstate);
43935 if (PyErr_Occurred()) SWIG_fail;
43936 }
43937 {
43938 wxSize * resultptr;
43939 resultptr = new wxSize(static_cast<wxSize & >(result));
43940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43941 }
43942 return resultobj;
43943 fail:
43944 return NULL;
43945 }
43946
43947
43948 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43949 PyObject *resultobj = NULL;
43950 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43951 wxSize result;
43952 PyObject * obj0 = 0 ;
43953 char *kwnames[] = {
43954 (char *) "self", NULL
43955 };
43956
43957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43959 if (SWIG_arg_fail(1)) SWIG_fail;
43960 {
43961 PyThreadState* __tstate = wxPyBeginAllowThreads();
43962 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43963
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 {
43968 wxSize * resultptr;
43969 resultptr = new wxSize(static_cast<wxSize & >(result));
43970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43971 }
43972 return resultobj;
43973 fail:
43974 return NULL;
43975 }
43976
43977
43978 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43979 PyObject *resultobj = NULL;
43980 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43981 wxSize *arg2 = 0 ;
43982 wxSize temp2 ;
43983 PyObject * obj0 = 0 ;
43984 PyObject * obj1 = 0 ;
43985 char *kwnames[] = {
43986 (char *) "self",(char *) "sz", NULL
43987 };
43988
43989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43991 if (SWIG_arg_fail(1)) SWIG_fail;
43992 {
43993 arg2 = &temp2;
43994 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43995 }
43996 {
43997 PyThreadState* __tstate = wxPyBeginAllowThreads();
43998 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43999
44000 wxPyEndAllowThreads(__tstate);
44001 if (PyErr_Occurred()) SWIG_fail;
44002 }
44003 Py_INCREF(Py_None); resultobj = Py_None;
44004 return resultobj;
44005 fail:
44006 return NULL;
44007 }
44008
44009
44010 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44011 PyObject *resultobj = NULL;
44012 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44013 wxWindow *arg2 = (wxWindow *) 0 ;
44014 wxGBPosition result;
44015 PyObject * obj0 = 0 ;
44016 PyObject * obj1 = 0 ;
44017
44018 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44020 if (SWIG_arg_fail(1)) SWIG_fail;
44021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44022 if (SWIG_arg_fail(2)) SWIG_fail;
44023 {
44024 PyThreadState* __tstate = wxPyBeginAllowThreads();
44025 result = (arg1)->GetItemPosition(arg2);
44026
44027 wxPyEndAllowThreads(__tstate);
44028 if (PyErr_Occurred()) SWIG_fail;
44029 }
44030 {
44031 wxGBPosition * resultptr;
44032 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44033 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44034 }
44035 return resultobj;
44036 fail:
44037 return NULL;
44038 }
44039
44040
44041 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44042 PyObject *resultobj = NULL;
44043 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44044 wxSizer *arg2 = (wxSizer *) 0 ;
44045 wxGBPosition result;
44046 PyObject * obj0 = 0 ;
44047 PyObject * obj1 = 0 ;
44048
44049 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44051 if (SWIG_arg_fail(1)) SWIG_fail;
44052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44053 if (SWIG_arg_fail(2)) SWIG_fail;
44054 {
44055 PyThreadState* __tstate = wxPyBeginAllowThreads();
44056 result = (arg1)->GetItemPosition(arg2);
44057
44058 wxPyEndAllowThreads(__tstate);
44059 if (PyErr_Occurred()) SWIG_fail;
44060 }
44061 {
44062 wxGBPosition * resultptr;
44063 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44064 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44065 }
44066 return resultobj;
44067 fail:
44068 return NULL;
44069 }
44070
44071
44072 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44073 PyObject *resultobj = NULL;
44074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44075 size_t arg2 ;
44076 wxGBPosition result;
44077 PyObject * obj0 = 0 ;
44078 PyObject * obj1 = 0 ;
44079
44080 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44082 if (SWIG_arg_fail(1)) SWIG_fail;
44083 {
44084 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44085 if (SWIG_arg_fail(2)) SWIG_fail;
44086 }
44087 {
44088 PyThreadState* __tstate = wxPyBeginAllowThreads();
44089 result = (arg1)->GetItemPosition(arg2);
44090
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 {
44095 wxGBPosition * resultptr;
44096 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44098 }
44099 return resultobj;
44100 fail:
44101 return NULL;
44102 }
44103
44104
44105 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44106 int argc;
44107 PyObject *argv[3];
44108 int ii;
44109
44110 argc = PyObject_Length(args);
44111 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44112 argv[ii] = PyTuple_GetItem(args,ii);
44113 }
44114 if (argc == 2) {
44115 int _v;
44116 {
44117 void *ptr;
44118 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44119 _v = 0;
44120 PyErr_Clear();
44121 } else {
44122 _v = 1;
44123 }
44124 }
44125 if (_v) {
44126 {
44127 void *ptr;
44128 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44129 _v = 0;
44130 PyErr_Clear();
44131 } else {
44132 _v = 1;
44133 }
44134 }
44135 if (_v) {
44136 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44137 }
44138 }
44139 }
44140 if (argc == 2) {
44141 int _v;
44142 {
44143 void *ptr;
44144 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44145 _v = 0;
44146 PyErr_Clear();
44147 } else {
44148 _v = 1;
44149 }
44150 }
44151 if (_v) {
44152 {
44153 void *ptr;
44154 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44155 _v = 0;
44156 PyErr_Clear();
44157 } else {
44158 _v = 1;
44159 }
44160 }
44161 if (_v) {
44162 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44163 }
44164 }
44165 }
44166 if (argc == 2) {
44167 int _v;
44168 {
44169 void *ptr;
44170 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44171 _v = 0;
44172 PyErr_Clear();
44173 } else {
44174 _v = 1;
44175 }
44176 }
44177 if (_v) {
44178 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44179 if (_v) {
44180 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44181 }
44182 }
44183 }
44184
44185 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44186 return NULL;
44187 }
44188
44189
44190 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44191 PyObject *resultobj = NULL;
44192 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44193 wxWindow *arg2 = (wxWindow *) 0 ;
44194 wxGBPosition *arg3 = 0 ;
44195 bool result;
44196 wxGBPosition temp3 ;
44197 PyObject * obj0 = 0 ;
44198 PyObject * obj1 = 0 ;
44199 PyObject * obj2 = 0 ;
44200
44201 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44203 if (SWIG_arg_fail(1)) SWIG_fail;
44204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44205 if (SWIG_arg_fail(2)) SWIG_fail;
44206 {
44207 arg3 = &temp3;
44208 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44209 }
44210 {
44211 PyThreadState* __tstate = wxPyBeginAllowThreads();
44212 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44213
44214 wxPyEndAllowThreads(__tstate);
44215 if (PyErr_Occurred()) SWIG_fail;
44216 }
44217 {
44218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44219 }
44220 return resultobj;
44221 fail:
44222 return NULL;
44223 }
44224
44225
44226 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44227 PyObject *resultobj = NULL;
44228 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44229 wxSizer *arg2 = (wxSizer *) 0 ;
44230 wxGBPosition *arg3 = 0 ;
44231 bool result;
44232 wxGBPosition temp3 ;
44233 PyObject * obj0 = 0 ;
44234 PyObject * obj1 = 0 ;
44235 PyObject * obj2 = 0 ;
44236
44237 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44239 if (SWIG_arg_fail(1)) SWIG_fail;
44240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44241 if (SWIG_arg_fail(2)) SWIG_fail;
44242 {
44243 arg3 = &temp3;
44244 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44245 }
44246 {
44247 PyThreadState* __tstate = wxPyBeginAllowThreads();
44248 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44249
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 {
44254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44255 }
44256 return resultobj;
44257 fail:
44258 return NULL;
44259 }
44260
44261
44262 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44263 PyObject *resultobj = NULL;
44264 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44265 size_t arg2 ;
44266 wxGBPosition *arg3 = 0 ;
44267 bool result;
44268 wxGBPosition temp3 ;
44269 PyObject * obj0 = 0 ;
44270 PyObject * obj1 = 0 ;
44271 PyObject * obj2 = 0 ;
44272
44273 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44275 if (SWIG_arg_fail(1)) SWIG_fail;
44276 {
44277 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44278 if (SWIG_arg_fail(2)) SWIG_fail;
44279 }
44280 {
44281 arg3 = &temp3;
44282 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44283 }
44284 {
44285 PyThreadState* __tstate = wxPyBeginAllowThreads();
44286 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44287
44288 wxPyEndAllowThreads(__tstate);
44289 if (PyErr_Occurred()) SWIG_fail;
44290 }
44291 {
44292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44293 }
44294 return resultobj;
44295 fail:
44296 return NULL;
44297 }
44298
44299
44300 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44301 int argc;
44302 PyObject *argv[4];
44303 int ii;
44304
44305 argc = PyObject_Length(args);
44306 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44307 argv[ii] = PyTuple_GetItem(args,ii);
44308 }
44309 if (argc == 3) {
44310 int _v;
44311 {
44312 void *ptr;
44313 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44314 _v = 0;
44315 PyErr_Clear();
44316 } else {
44317 _v = 1;
44318 }
44319 }
44320 if (_v) {
44321 {
44322 void *ptr;
44323 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44324 _v = 0;
44325 PyErr_Clear();
44326 } else {
44327 _v = 1;
44328 }
44329 }
44330 if (_v) {
44331 {
44332 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44333 }
44334 if (_v) {
44335 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44336 }
44337 }
44338 }
44339 }
44340 if (argc == 3) {
44341 int _v;
44342 {
44343 void *ptr;
44344 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44345 _v = 0;
44346 PyErr_Clear();
44347 } else {
44348 _v = 1;
44349 }
44350 }
44351 if (_v) {
44352 {
44353 void *ptr;
44354 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44355 _v = 0;
44356 PyErr_Clear();
44357 } else {
44358 _v = 1;
44359 }
44360 }
44361 if (_v) {
44362 {
44363 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44364 }
44365 if (_v) {
44366 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44367 }
44368 }
44369 }
44370 }
44371 if (argc == 3) {
44372 int _v;
44373 {
44374 void *ptr;
44375 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44376 _v = 0;
44377 PyErr_Clear();
44378 } else {
44379 _v = 1;
44380 }
44381 }
44382 if (_v) {
44383 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44384 if (_v) {
44385 {
44386 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44387 }
44388 if (_v) {
44389 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44390 }
44391 }
44392 }
44393 }
44394
44395 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44396 return NULL;
44397 }
44398
44399
44400 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44401 PyObject *resultobj = NULL;
44402 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44403 wxWindow *arg2 = (wxWindow *) 0 ;
44404 wxGBSpan result;
44405 PyObject * obj0 = 0 ;
44406 PyObject * obj1 = 0 ;
44407
44408 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44410 if (SWIG_arg_fail(1)) SWIG_fail;
44411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44412 if (SWIG_arg_fail(2)) SWIG_fail;
44413 {
44414 PyThreadState* __tstate = wxPyBeginAllowThreads();
44415 result = (arg1)->GetItemSpan(arg2);
44416
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 {
44421 wxGBSpan * resultptr;
44422 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44424 }
44425 return resultobj;
44426 fail:
44427 return NULL;
44428 }
44429
44430
44431 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44432 PyObject *resultobj = NULL;
44433 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44434 wxSizer *arg2 = (wxSizer *) 0 ;
44435 wxGBSpan result;
44436 PyObject * obj0 = 0 ;
44437 PyObject * obj1 = 0 ;
44438
44439 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44441 if (SWIG_arg_fail(1)) SWIG_fail;
44442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44443 if (SWIG_arg_fail(2)) SWIG_fail;
44444 {
44445 PyThreadState* __tstate = wxPyBeginAllowThreads();
44446 result = (arg1)->GetItemSpan(arg2);
44447
44448 wxPyEndAllowThreads(__tstate);
44449 if (PyErr_Occurred()) SWIG_fail;
44450 }
44451 {
44452 wxGBSpan * resultptr;
44453 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44455 }
44456 return resultobj;
44457 fail:
44458 return NULL;
44459 }
44460
44461
44462 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44463 PyObject *resultobj = NULL;
44464 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44465 size_t arg2 ;
44466 wxGBSpan result;
44467 PyObject * obj0 = 0 ;
44468 PyObject * obj1 = 0 ;
44469
44470 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44472 if (SWIG_arg_fail(1)) SWIG_fail;
44473 {
44474 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44475 if (SWIG_arg_fail(2)) SWIG_fail;
44476 }
44477 {
44478 PyThreadState* __tstate = wxPyBeginAllowThreads();
44479 result = (arg1)->GetItemSpan(arg2);
44480
44481 wxPyEndAllowThreads(__tstate);
44482 if (PyErr_Occurred()) SWIG_fail;
44483 }
44484 {
44485 wxGBSpan * resultptr;
44486 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44488 }
44489 return resultobj;
44490 fail:
44491 return NULL;
44492 }
44493
44494
44495 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44496 int argc;
44497 PyObject *argv[3];
44498 int ii;
44499
44500 argc = PyObject_Length(args);
44501 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44502 argv[ii] = PyTuple_GetItem(args,ii);
44503 }
44504 if (argc == 2) {
44505 int _v;
44506 {
44507 void *ptr;
44508 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44509 _v = 0;
44510 PyErr_Clear();
44511 } else {
44512 _v = 1;
44513 }
44514 }
44515 if (_v) {
44516 {
44517 void *ptr;
44518 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44519 _v = 0;
44520 PyErr_Clear();
44521 } else {
44522 _v = 1;
44523 }
44524 }
44525 if (_v) {
44526 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44527 }
44528 }
44529 }
44530 if (argc == 2) {
44531 int _v;
44532 {
44533 void *ptr;
44534 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44535 _v = 0;
44536 PyErr_Clear();
44537 } else {
44538 _v = 1;
44539 }
44540 }
44541 if (_v) {
44542 {
44543 void *ptr;
44544 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44545 _v = 0;
44546 PyErr_Clear();
44547 } else {
44548 _v = 1;
44549 }
44550 }
44551 if (_v) {
44552 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44553 }
44554 }
44555 }
44556 if (argc == 2) {
44557 int _v;
44558 {
44559 void *ptr;
44560 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44561 _v = 0;
44562 PyErr_Clear();
44563 } else {
44564 _v = 1;
44565 }
44566 }
44567 if (_v) {
44568 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44569 if (_v) {
44570 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44571 }
44572 }
44573 }
44574
44575 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44576 return NULL;
44577 }
44578
44579
44580 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44581 PyObject *resultobj = NULL;
44582 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44583 wxWindow *arg2 = (wxWindow *) 0 ;
44584 wxGBSpan *arg3 = 0 ;
44585 bool result;
44586 wxGBSpan temp3 ;
44587 PyObject * obj0 = 0 ;
44588 PyObject * obj1 = 0 ;
44589 PyObject * obj2 = 0 ;
44590
44591 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44593 if (SWIG_arg_fail(1)) SWIG_fail;
44594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44595 if (SWIG_arg_fail(2)) SWIG_fail;
44596 {
44597 arg3 = &temp3;
44598 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44599 }
44600 {
44601 PyThreadState* __tstate = wxPyBeginAllowThreads();
44602 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44603
44604 wxPyEndAllowThreads(__tstate);
44605 if (PyErr_Occurred()) SWIG_fail;
44606 }
44607 {
44608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44609 }
44610 return resultobj;
44611 fail:
44612 return NULL;
44613 }
44614
44615
44616 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44617 PyObject *resultobj = NULL;
44618 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44619 wxSizer *arg2 = (wxSizer *) 0 ;
44620 wxGBSpan *arg3 = 0 ;
44621 bool result;
44622 wxGBSpan temp3 ;
44623 PyObject * obj0 = 0 ;
44624 PyObject * obj1 = 0 ;
44625 PyObject * obj2 = 0 ;
44626
44627 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44629 if (SWIG_arg_fail(1)) SWIG_fail;
44630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44631 if (SWIG_arg_fail(2)) SWIG_fail;
44632 {
44633 arg3 = &temp3;
44634 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44635 }
44636 {
44637 PyThreadState* __tstate = wxPyBeginAllowThreads();
44638 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44639
44640 wxPyEndAllowThreads(__tstate);
44641 if (PyErr_Occurred()) SWIG_fail;
44642 }
44643 {
44644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44645 }
44646 return resultobj;
44647 fail:
44648 return NULL;
44649 }
44650
44651
44652 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44653 PyObject *resultobj = NULL;
44654 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44655 size_t arg2 ;
44656 wxGBSpan *arg3 = 0 ;
44657 bool result;
44658 wxGBSpan temp3 ;
44659 PyObject * obj0 = 0 ;
44660 PyObject * obj1 = 0 ;
44661 PyObject * obj2 = 0 ;
44662
44663 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44665 if (SWIG_arg_fail(1)) SWIG_fail;
44666 {
44667 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44668 if (SWIG_arg_fail(2)) SWIG_fail;
44669 }
44670 {
44671 arg3 = &temp3;
44672 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44673 }
44674 {
44675 PyThreadState* __tstate = wxPyBeginAllowThreads();
44676 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44677
44678 wxPyEndAllowThreads(__tstate);
44679 if (PyErr_Occurred()) SWIG_fail;
44680 }
44681 {
44682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44683 }
44684 return resultobj;
44685 fail:
44686 return NULL;
44687 }
44688
44689
44690 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44691 int argc;
44692 PyObject *argv[4];
44693 int ii;
44694
44695 argc = PyObject_Length(args);
44696 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44697 argv[ii] = PyTuple_GetItem(args,ii);
44698 }
44699 if (argc == 3) {
44700 int _v;
44701 {
44702 void *ptr;
44703 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44704 _v = 0;
44705 PyErr_Clear();
44706 } else {
44707 _v = 1;
44708 }
44709 }
44710 if (_v) {
44711 {
44712 void *ptr;
44713 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44714 _v = 0;
44715 PyErr_Clear();
44716 } else {
44717 _v = 1;
44718 }
44719 }
44720 if (_v) {
44721 {
44722 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44723 }
44724 if (_v) {
44725 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44726 }
44727 }
44728 }
44729 }
44730 if (argc == 3) {
44731 int _v;
44732 {
44733 void *ptr;
44734 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44735 _v = 0;
44736 PyErr_Clear();
44737 } else {
44738 _v = 1;
44739 }
44740 }
44741 if (_v) {
44742 {
44743 void *ptr;
44744 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44745 _v = 0;
44746 PyErr_Clear();
44747 } else {
44748 _v = 1;
44749 }
44750 }
44751 if (_v) {
44752 {
44753 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44754 }
44755 if (_v) {
44756 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44757 }
44758 }
44759 }
44760 }
44761 if (argc == 3) {
44762 int _v;
44763 {
44764 void *ptr;
44765 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44766 _v = 0;
44767 PyErr_Clear();
44768 } else {
44769 _v = 1;
44770 }
44771 }
44772 if (_v) {
44773 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44774 if (_v) {
44775 {
44776 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44777 }
44778 if (_v) {
44779 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44780 }
44781 }
44782 }
44783 }
44784
44785 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44786 return NULL;
44787 }
44788
44789
44790 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44791 PyObject *resultobj = NULL;
44792 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44793 wxWindow *arg2 = (wxWindow *) 0 ;
44794 wxGBSizerItem *result;
44795 PyObject * obj0 = 0 ;
44796 PyObject * obj1 = 0 ;
44797
44798 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44800 if (SWIG_arg_fail(1)) SWIG_fail;
44801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44802 if (SWIG_arg_fail(2)) SWIG_fail;
44803 {
44804 PyThreadState* __tstate = wxPyBeginAllowThreads();
44805 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44806
44807 wxPyEndAllowThreads(__tstate);
44808 if (PyErr_Occurred()) SWIG_fail;
44809 }
44810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44811 return resultobj;
44812 fail:
44813 return NULL;
44814 }
44815
44816
44817 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44818 PyObject *resultobj = NULL;
44819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44820 wxSizer *arg2 = (wxSizer *) 0 ;
44821 wxGBSizerItem *result;
44822 PyObject * obj0 = 0 ;
44823 PyObject * obj1 = 0 ;
44824
44825 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44827 if (SWIG_arg_fail(1)) SWIG_fail;
44828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44829 if (SWIG_arg_fail(2)) SWIG_fail;
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44833
44834 wxPyEndAllowThreads(__tstate);
44835 if (PyErr_Occurred()) SWIG_fail;
44836 }
44837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44845 int argc;
44846 PyObject *argv[3];
44847 int ii;
44848
44849 argc = PyObject_Length(args);
44850 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44851 argv[ii] = PyTuple_GetItem(args,ii);
44852 }
44853 if (argc == 2) {
44854 int _v;
44855 {
44856 void *ptr;
44857 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44858 _v = 0;
44859 PyErr_Clear();
44860 } else {
44861 _v = 1;
44862 }
44863 }
44864 if (_v) {
44865 {
44866 void *ptr;
44867 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44868 _v = 0;
44869 PyErr_Clear();
44870 } else {
44871 _v = 1;
44872 }
44873 }
44874 if (_v) {
44875 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44876 }
44877 }
44878 }
44879 if (argc == 2) {
44880 int _v;
44881 {
44882 void *ptr;
44883 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44884 _v = 0;
44885 PyErr_Clear();
44886 } else {
44887 _v = 1;
44888 }
44889 }
44890 if (_v) {
44891 {
44892 void *ptr;
44893 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44894 _v = 0;
44895 PyErr_Clear();
44896 } else {
44897 _v = 1;
44898 }
44899 }
44900 if (_v) {
44901 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44902 }
44903 }
44904 }
44905
44906 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44907 return NULL;
44908 }
44909
44910
44911 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44912 PyObject *resultobj = NULL;
44913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44914 wxGBPosition *arg2 = 0 ;
44915 wxGBSizerItem *result;
44916 wxGBPosition temp2 ;
44917 PyObject * obj0 = 0 ;
44918 PyObject * obj1 = 0 ;
44919 char *kwnames[] = {
44920 (char *) "self",(char *) "pos", NULL
44921 };
44922
44923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44925 if (SWIG_arg_fail(1)) SWIG_fail;
44926 {
44927 arg2 = &temp2;
44928 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44929 }
44930 {
44931 PyThreadState* __tstate = wxPyBeginAllowThreads();
44932 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44933
44934 wxPyEndAllowThreads(__tstate);
44935 if (PyErr_Occurred()) SWIG_fail;
44936 }
44937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44938 return resultobj;
44939 fail:
44940 return NULL;
44941 }
44942
44943
44944 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44945 PyObject *resultobj = NULL;
44946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44947 wxPoint *arg2 = 0 ;
44948 wxGBSizerItem *result;
44949 wxPoint temp2 ;
44950 PyObject * obj0 = 0 ;
44951 PyObject * obj1 = 0 ;
44952 char *kwnames[] = {
44953 (char *) "self",(char *) "pt", NULL
44954 };
44955
44956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44958 if (SWIG_arg_fail(1)) SWIG_fail;
44959 {
44960 arg2 = &temp2;
44961 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44962 }
44963 {
44964 PyThreadState* __tstate = wxPyBeginAllowThreads();
44965 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44966
44967 wxPyEndAllowThreads(__tstate);
44968 if (PyErr_Occurred()) SWIG_fail;
44969 }
44970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44971 return resultobj;
44972 fail:
44973 return NULL;
44974 }
44975
44976
44977 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44978 PyObject *resultobj = NULL;
44979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44980 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44981 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44982 bool result;
44983 PyObject * obj0 = 0 ;
44984 PyObject * obj1 = 0 ;
44985 PyObject * obj2 = 0 ;
44986 char *kwnames[] = {
44987 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44988 };
44989
44990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44992 if (SWIG_arg_fail(1)) SWIG_fail;
44993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44994 if (SWIG_arg_fail(2)) SWIG_fail;
44995 if (obj2) {
44996 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44997 if (SWIG_arg_fail(3)) SWIG_fail;
44998 }
44999 {
45000 PyThreadState* __tstate = wxPyBeginAllowThreads();
45001 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45002
45003 wxPyEndAllowThreads(__tstate);
45004 if (PyErr_Occurred()) SWIG_fail;
45005 }
45006 {
45007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45008 }
45009 return resultobj;
45010 fail:
45011 return NULL;
45012 }
45013
45014
45015 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45016 PyObject *resultobj = NULL;
45017 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45018 wxGBPosition *arg2 = 0 ;
45019 wxGBSpan *arg3 = 0 ;
45020 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45021 bool result;
45022 wxGBPosition temp2 ;
45023 wxGBSpan temp3 ;
45024 PyObject * obj0 = 0 ;
45025 PyObject * obj1 = 0 ;
45026 PyObject * obj2 = 0 ;
45027 PyObject * obj3 = 0 ;
45028 char *kwnames[] = {
45029 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45030 };
45031
45032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45034 if (SWIG_arg_fail(1)) SWIG_fail;
45035 {
45036 arg2 = &temp2;
45037 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45038 }
45039 {
45040 arg3 = &temp3;
45041 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45042 }
45043 if (obj3) {
45044 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45045 if (SWIG_arg_fail(4)) SWIG_fail;
45046 }
45047 {
45048 PyThreadState* __tstate = wxPyBeginAllowThreads();
45049 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45050
45051 wxPyEndAllowThreads(__tstate);
45052 if (PyErr_Occurred()) SWIG_fail;
45053 }
45054 {
45055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45056 }
45057 return resultobj;
45058 fail:
45059 return NULL;
45060 }
45061
45062
45063 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45064 PyObject *obj;
45065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45066 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45067 Py_INCREF(obj);
45068 return Py_BuildValue((char *)"");
45069 }
45070 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45071 PyObject *resultobj = NULL;
45072 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45073 wxRelationship arg2 ;
45074 wxWindow *arg3 = (wxWindow *) 0 ;
45075 wxEdge arg4 ;
45076 int arg5 = (int) 0 ;
45077 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45078 PyObject * obj0 = 0 ;
45079 PyObject * obj1 = 0 ;
45080 PyObject * obj2 = 0 ;
45081 PyObject * obj3 = 0 ;
45082 PyObject * obj4 = 0 ;
45083 PyObject * obj5 = 0 ;
45084 char *kwnames[] = {
45085 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45086 };
45087
45088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45090 if (SWIG_arg_fail(1)) SWIG_fail;
45091 {
45092 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45093 if (SWIG_arg_fail(2)) SWIG_fail;
45094 }
45095 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45096 if (SWIG_arg_fail(3)) SWIG_fail;
45097 {
45098 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45099 if (SWIG_arg_fail(4)) SWIG_fail;
45100 }
45101 if (obj4) {
45102 {
45103 arg5 = static_cast<int >(SWIG_As_int(obj4));
45104 if (SWIG_arg_fail(5)) SWIG_fail;
45105 }
45106 }
45107 if (obj5) {
45108 {
45109 arg6 = static_cast<int >(SWIG_As_int(obj5));
45110 if (SWIG_arg_fail(6)) SWIG_fail;
45111 }
45112 }
45113 {
45114 PyThreadState* __tstate = wxPyBeginAllowThreads();
45115 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45116
45117 wxPyEndAllowThreads(__tstate);
45118 if (PyErr_Occurred()) SWIG_fail;
45119 }
45120 Py_INCREF(Py_None); resultobj = Py_None;
45121 return resultobj;
45122 fail:
45123 return NULL;
45124 }
45125
45126
45127 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45128 PyObject *resultobj = NULL;
45129 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45130 wxWindow *arg2 = (wxWindow *) 0 ;
45131 int arg3 = (int) 0 ;
45132 PyObject * obj0 = 0 ;
45133 PyObject * obj1 = 0 ;
45134 PyObject * obj2 = 0 ;
45135 char *kwnames[] = {
45136 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45137 };
45138
45139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45141 if (SWIG_arg_fail(1)) SWIG_fail;
45142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45143 if (SWIG_arg_fail(2)) SWIG_fail;
45144 if (obj2) {
45145 {
45146 arg3 = static_cast<int >(SWIG_As_int(obj2));
45147 if (SWIG_arg_fail(3)) SWIG_fail;
45148 }
45149 }
45150 {
45151 PyThreadState* __tstate = wxPyBeginAllowThreads();
45152 (arg1)->LeftOf(arg2,arg3);
45153
45154 wxPyEndAllowThreads(__tstate);
45155 if (PyErr_Occurred()) SWIG_fail;
45156 }
45157 Py_INCREF(Py_None); resultobj = Py_None;
45158 return resultobj;
45159 fail:
45160 return NULL;
45161 }
45162
45163
45164 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45165 PyObject *resultobj = NULL;
45166 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45167 wxWindow *arg2 = (wxWindow *) 0 ;
45168 int arg3 = (int) 0 ;
45169 PyObject * obj0 = 0 ;
45170 PyObject * obj1 = 0 ;
45171 PyObject * obj2 = 0 ;
45172 char *kwnames[] = {
45173 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45174 };
45175
45176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45178 if (SWIG_arg_fail(1)) SWIG_fail;
45179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45180 if (SWIG_arg_fail(2)) SWIG_fail;
45181 if (obj2) {
45182 {
45183 arg3 = static_cast<int >(SWIG_As_int(obj2));
45184 if (SWIG_arg_fail(3)) SWIG_fail;
45185 }
45186 }
45187 {
45188 PyThreadState* __tstate = wxPyBeginAllowThreads();
45189 (arg1)->RightOf(arg2,arg3);
45190
45191 wxPyEndAllowThreads(__tstate);
45192 if (PyErr_Occurred()) SWIG_fail;
45193 }
45194 Py_INCREF(Py_None); resultobj = Py_None;
45195 return resultobj;
45196 fail:
45197 return NULL;
45198 }
45199
45200
45201 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45202 PyObject *resultobj = NULL;
45203 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45204 wxWindow *arg2 = (wxWindow *) 0 ;
45205 int arg3 = (int) 0 ;
45206 PyObject * obj0 = 0 ;
45207 PyObject * obj1 = 0 ;
45208 PyObject * obj2 = 0 ;
45209 char *kwnames[] = {
45210 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45211 };
45212
45213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45215 if (SWIG_arg_fail(1)) SWIG_fail;
45216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45217 if (SWIG_arg_fail(2)) SWIG_fail;
45218 if (obj2) {
45219 {
45220 arg3 = static_cast<int >(SWIG_As_int(obj2));
45221 if (SWIG_arg_fail(3)) SWIG_fail;
45222 }
45223 }
45224 {
45225 PyThreadState* __tstate = wxPyBeginAllowThreads();
45226 (arg1)->Above(arg2,arg3);
45227
45228 wxPyEndAllowThreads(__tstate);
45229 if (PyErr_Occurred()) SWIG_fail;
45230 }
45231 Py_INCREF(Py_None); resultobj = Py_None;
45232 return resultobj;
45233 fail:
45234 return NULL;
45235 }
45236
45237
45238 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45239 PyObject *resultobj = NULL;
45240 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45241 wxWindow *arg2 = (wxWindow *) 0 ;
45242 int arg3 = (int) 0 ;
45243 PyObject * obj0 = 0 ;
45244 PyObject * obj1 = 0 ;
45245 PyObject * obj2 = 0 ;
45246 char *kwnames[] = {
45247 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45248 };
45249
45250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45252 if (SWIG_arg_fail(1)) SWIG_fail;
45253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45254 if (SWIG_arg_fail(2)) SWIG_fail;
45255 if (obj2) {
45256 {
45257 arg3 = static_cast<int >(SWIG_As_int(obj2));
45258 if (SWIG_arg_fail(3)) SWIG_fail;
45259 }
45260 }
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 (arg1)->Below(arg2,arg3);
45264
45265 wxPyEndAllowThreads(__tstate);
45266 if (PyErr_Occurred()) SWIG_fail;
45267 }
45268 Py_INCREF(Py_None); resultobj = Py_None;
45269 return resultobj;
45270 fail:
45271 return NULL;
45272 }
45273
45274
45275 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45276 PyObject *resultobj = NULL;
45277 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45278 wxWindow *arg2 = (wxWindow *) 0 ;
45279 wxEdge arg3 ;
45280 int arg4 = (int) 0 ;
45281 PyObject * obj0 = 0 ;
45282 PyObject * obj1 = 0 ;
45283 PyObject * obj2 = 0 ;
45284 PyObject * obj3 = 0 ;
45285 char *kwnames[] = {
45286 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45287 };
45288
45289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45291 if (SWIG_arg_fail(1)) SWIG_fail;
45292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45293 if (SWIG_arg_fail(2)) SWIG_fail;
45294 {
45295 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45296 if (SWIG_arg_fail(3)) SWIG_fail;
45297 }
45298 if (obj3) {
45299 {
45300 arg4 = static_cast<int >(SWIG_As_int(obj3));
45301 if (SWIG_arg_fail(4)) SWIG_fail;
45302 }
45303 }
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 (arg1)->SameAs(arg2,arg3,arg4);
45307
45308 wxPyEndAllowThreads(__tstate);
45309 if (PyErr_Occurred()) SWIG_fail;
45310 }
45311 Py_INCREF(Py_None); resultobj = Py_None;
45312 return resultobj;
45313 fail:
45314 return NULL;
45315 }
45316
45317
45318 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45319 PyObject *resultobj = NULL;
45320 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45321 wxWindow *arg2 = (wxWindow *) 0 ;
45322 wxEdge arg3 ;
45323 int arg4 ;
45324 PyObject * obj0 = 0 ;
45325 PyObject * obj1 = 0 ;
45326 PyObject * obj2 = 0 ;
45327 PyObject * obj3 = 0 ;
45328 char *kwnames[] = {
45329 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45330 };
45331
45332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45334 if (SWIG_arg_fail(1)) SWIG_fail;
45335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45336 if (SWIG_arg_fail(2)) SWIG_fail;
45337 {
45338 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45339 if (SWIG_arg_fail(3)) SWIG_fail;
45340 }
45341 {
45342 arg4 = static_cast<int >(SWIG_As_int(obj3));
45343 if (SWIG_arg_fail(4)) SWIG_fail;
45344 }
45345 {
45346 PyThreadState* __tstate = wxPyBeginAllowThreads();
45347 (arg1)->PercentOf(arg2,arg3,arg4);
45348
45349 wxPyEndAllowThreads(__tstate);
45350 if (PyErr_Occurred()) SWIG_fail;
45351 }
45352 Py_INCREF(Py_None); resultobj = Py_None;
45353 return resultobj;
45354 fail:
45355 return NULL;
45356 }
45357
45358
45359 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45360 PyObject *resultobj = NULL;
45361 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45362 int arg2 ;
45363 PyObject * obj0 = 0 ;
45364 PyObject * obj1 = 0 ;
45365 char *kwnames[] = {
45366 (char *) "self",(char *) "val", NULL
45367 };
45368
45369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45371 if (SWIG_arg_fail(1)) SWIG_fail;
45372 {
45373 arg2 = static_cast<int >(SWIG_As_int(obj1));
45374 if (SWIG_arg_fail(2)) SWIG_fail;
45375 }
45376 {
45377 PyThreadState* __tstate = wxPyBeginAllowThreads();
45378 (arg1)->Absolute(arg2);
45379
45380 wxPyEndAllowThreads(__tstate);
45381 if (PyErr_Occurred()) SWIG_fail;
45382 }
45383 Py_INCREF(Py_None); resultobj = Py_None;
45384 return resultobj;
45385 fail:
45386 return NULL;
45387 }
45388
45389
45390 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45391 PyObject *resultobj = NULL;
45392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45393 PyObject * obj0 = 0 ;
45394 char *kwnames[] = {
45395 (char *) "self", NULL
45396 };
45397
45398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45400 if (SWIG_arg_fail(1)) SWIG_fail;
45401 {
45402 PyThreadState* __tstate = wxPyBeginAllowThreads();
45403 (arg1)->Unconstrained();
45404
45405 wxPyEndAllowThreads(__tstate);
45406 if (PyErr_Occurred()) SWIG_fail;
45407 }
45408 Py_INCREF(Py_None); resultobj = Py_None;
45409 return resultobj;
45410 fail:
45411 return NULL;
45412 }
45413
45414
45415 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45416 PyObject *resultobj = NULL;
45417 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45418 PyObject * obj0 = 0 ;
45419 char *kwnames[] = {
45420 (char *) "self", NULL
45421 };
45422
45423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45425 if (SWIG_arg_fail(1)) SWIG_fail;
45426 {
45427 PyThreadState* __tstate = wxPyBeginAllowThreads();
45428 (arg1)->AsIs();
45429
45430 wxPyEndAllowThreads(__tstate);
45431 if (PyErr_Occurred()) SWIG_fail;
45432 }
45433 Py_INCREF(Py_None); resultobj = Py_None;
45434 return resultobj;
45435 fail:
45436 return NULL;
45437 }
45438
45439
45440 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45441 PyObject *resultobj = NULL;
45442 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45443 wxWindow *result;
45444 PyObject * obj0 = 0 ;
45445 char *kwnames[] = {
45446 (char *) "self", NULL
45447 };
45448
45449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45451 if (SWIG_arg_fail(1)) SWIG_fail;
45452 {
45453 PyThreadState* __tstate = wxPyBeginAllowThreads();
45454 result = (wxWindow *)(arg1)->GetOtherWindow();
45455
45456 wxPyEndAllowThreads(__tstate);
45457 if (PyErr_Occurred()) SWIG_fail;
45458 }
45459 {
45460 resultobj = wxPyMake_wxObject(result, 0);
45461 }
45462 return resultobj;
45463 fail:
45464 return NULL;
45465 }
45466
45467
45468 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45469 PyObject *resultobj = NULL;
45470 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45471 wxEdge result;
45472 PyObject * obj0 = 0 ;
45473 char *kwnames[] = {
45474 (char *) "self", NULL
45475 };
45476
45477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45479 if (SWIG_arg_fail(1)) SWIG_fail;
45480 {
45481 PyThreadState* __tstate = wxPyBeginAllowThreads();
45482 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45483
45484 wxPyEndAllowThreads(__tstate);
45485 if (PyErr_Occurred()) SWIG_fail;
45486 }
45487 resultobj = SWIG_From_int((result));
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45495 PyObject *resultobj = NULL;
45496 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45497 wxEdge arg2 ;
45498 PyObject * obj0 = 0 ;
45499 PyObject * obj1 = 0 ;
45500 char *kwnames[] = {
45501 (char *) "self",(char *) "which", NULL
45502 };
45503
45504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45506 if (SWIG_arg_fail(1)) SWIG_fail;
45507 {
45508 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45509 if (SWIG_arg_fail(2)) SWIG_fail;
45510 }
45511 {
45512 PyThreadState* __tstate = wxPyBeginAllowThreads();
45513 (arg1)->SetEdge(arg2);
45514
45515 wxPyEndAllowThreads(__tstate);
45516 if (PyErr_Occurred()) SWIG_fail;
45517 }
45518 Py_INCREF(Py_None); resultobj = Py_None;
45519 return resultobj;
45520 fail:
45521 return NULL;
45522 }
45523
45524
45525 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45526 PyObject *resultobj = NULL;
45527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45528 int arg2 ;
45529 PyObject * obj0 = 0 ;
45530 PyObject * obj1 = 0 ;
45531 char *kwnames[] = {
45532 (char *) "self",(char *) "v", NULL
45533 };
45534
45535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45537 if (SWIG_arg_fail(1)) SWIG_fail;
45538 {
45539 arg2 = static_cast<int >(SWIG_As_int(obj1));
45540 if (SWIG_arg_fail(2)) SWIG_fail;
45541 }
45542 {
45543 PyThreadState* __tstate = wxPyBeginAllowThreads();
45544 (arg1)->SetValue(arg2);
45545
45546 wxPyEndAllowThreads(__tstate);
45547 if (PyErr_Occurred()) SWIG_fail;
45548 }
45549 Py_INCREF(Py_None); resultobj = Py_None;
45550 return resultobj;
45551 fail:
45552 return NULL;
45553 }
45554
45555
45556 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45557 PyObject *resultobj = NULL;
45558 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45559 int result;
45560 PyObject * obj0 = 0 ;
45561 char *kwnames[] = {
45562 (char *) "self", NULL
45563 };
45564
45565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45567 if (SWIG_arg_fail(1)) SWIG_fail;
45568 {
45569 PyThreadState* __tstate = wxPyBeginAllowThreads();
45570 result = (int)(arg1)->GetMargin();
45571
45572 wxPyEndAllowThreads(__tstate);
45573 if (PyErr_Occurred()) SWIG_fail;
45574 }
45575 {
45576 resultobj = SWIG_From_int(static_cast<int >(result));
45577 }
45578 return resultobj;
45579 fail:
45580 return NULL;
45581 }
45582
45583
45584 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45585 PyObject *resultobj = NULL;
45586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45587 int arg2 ;
45588 PyObject * obj0 = 0 ;
45589 PyObject * obj1 = 0 ;
45590 char *kwnames[] = {
45591 (char *) "self",(char *) "m", NULL
45592 };
45593
45594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45596 if (SWIG_arg_fail(1)) SWIG_fail;
45597 {
45598 arg2 = static_cast<int >(SWIG_As_int(obj1));
45599 if (SWIG_arg_fail(2)) SWIG_fail;
45600 }
45601 {
45602 PyThreadState* __tstate = wxPyBeginAllowThreads();
45603 (arg1)->SetMargin(arg2);
45604
45605 wxPyEndAllowThreads(__tstate);
45606 if (PyErr_Occurred()) SWIG_fail;
45607 }
45608 Py_INCREF(Py_None); resultobj = Py_None;
45609 return resultobj;
45610 fail:
45611 return NULL;
45612 }
45613
45614
45615 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45616 PyObject *resultobj = NULL;
45617 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45618 int result;
45619 PyObject * obj0 = 0 ;
45620 char *kwnames[] = {
45621 (char *) "self", NULL
45622 };
45623
45624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45626 if (SWIG_arg_fail(1)) SWIG_fail;
45627 {
45628 PyThreadState* __tstate = wxPyBeginAllowThreads();
45629 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45630
45631 wxPyEndAllowThreads(__tstate);
45632 if (PyErr_Occurred()) SWIG_fail;
45633 }
45634 {
45635 resultobj = SWIG_From_int(static_cast<int >(result));
45636 }
45637 return resultobj;
45638 fail:
45639 return NULL;
45640 }
45641
45642
45643 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45644 PyObject *resultobj = NULL;
45645 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45646 int result;
45647 PyObject * obj0 = 0 ;
45648 char *kwnames[] = {
45649 (char *) "self", NULL
45650 };
45651
45652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45654 if (SWIG_arg_fail(1)) SWIG_fail;
45655 {
45656 PyThreadState* __tstate = wxPyBeginAllowThreads();
45657 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45658
45659 wxPyEndAllowThreads(__tstate);
45660 if (PyErr_Occurred()) SWIG_fail;
45661 }
45662 {
45663 resultobj = SWIG_From_int(static_cast<int >(result));
45664 }
45665 return resultobj;
45666 fail:
45667 return NULL;
45668 }
45669
45670
45671 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45672 PyObject *resultobj = NULL;
45673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45674 int result;
45675 PyObject * obj0 = 0 ;
45676 char *kwnames[] = {
45677 (char *) "self", NULL
45678 };
45679
45680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45682 if (SWIG_arg_fail(1)) SWIG_fail;
45683 {
45684 PyThreadState* __tstate = wxPyBeginAllowThreads();
45685 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45686
45687 wxPyEndAllowThreads(__tstate);
45688 if (PyErr_Occurred()) SWIG_fail;
45689 }
45690 {
45691 resultobj = SWIG_From_int(static_cast<int >(result));
45692 }
45693 return resultobj;
45694 fail:
45695 return NULL;
45696 }
45697
45698
45699 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45700 PyObject *resultobj = NULL;
45701 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45702 bool result;
45703 PyObject * obj0 = 0 ;
45704 char *kwnames[] = {
45705 (char *) "self", NULL
45706 };
45707
45708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45710 if (SWIG_arg_fail(1)) SWIG_fail;
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45714
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 {
45719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45720 }
45721 return resultobj;
45722 fail:
45723 return NULL;
45724 }
45725
45726
45727 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45728 PyObject *resultobj = NULL;
45729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45730 bool arg2 ;
45731 PyObject * obj0 = 0 ;
45732 PyObject * obj1 = 0 ;
45733 char *kwnames[] = {
45734 (char *) "self",(char *) "d", NULL
45735 };
45736
45737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45739 if (SWIG_arg_fail(1)) SWIG_fail;
45740 {
45741 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45742 if (SWIG_arg_fail(2)) SWIG_fail;
45743 }
45744 {
45745 PyThreadState* __tstate = wxPyBeginAllowThreads();
45746 (arg1)->SetDone(arg2);
45747
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 Py_INCREF(Py_None); resultobj = Py_None;
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45759 PyObject *resultobj = NULL;
45760 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45761 wxRelationship result;
45762 PyObject * obj0 = 0 ;
45763 char *kwnames[] = {
45764 (char *) "self", NULL
45765 };
45766
45767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45769 if (SWIG_arg_fail(1)) SWIG_fail;
45770 {
45771 PyThreadState* __tstate = wxPyBeginAllowThreads();
45772 result = (wxRelationship)(arg1)->GetRelationship();
45773
45774 wxPyEndAllowThreads(__tstate);
45775 if (PyErr_Occurred()) SWIG_fail;
45776 }
45777 resultobj = SWIG_From_int((result));
45778 return resultobj;
45779 fail:
45780 return NULL;
45781 }
45782
45783
45784 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45785 PyObject *resultobj = NULL;
45786 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45787 wxRelationship arg2 ;
45788 PyObject * obj0 = 0 ;
45789 PyObject * obj1 = 0 ;
45790 char *kwnames[] = {
45791 (char *) "self",(char *) "r", NULL
45792 };
45793
45794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45796 if (SWIG_arg_fail(1)) SWIG_fail;
45797 {
45798 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45799 if (SWIG_arg_fail(2)) SWIG_fail;
45800 }
45801 {
45802 PyThreadState* __tstate = wxPyBeginAllowThreads();
45803 (arg1)->SetRelationship(arg2);
45804
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 Py_INCREF(Py_None); resultobj = Py_None;
45809 return resultobj;
45810 fail:
45811 return NULL;
45812 }
45813
45814
45815 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45816 PyObject *resultobj = NULL;
45817 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45818 wxWindow *arg2 = (wxWindow *) 0 ;
45819 bool result;
45820 PyObject * obj0 = 0 ;
45821 PyObject * obj1 = 0 ;
45822 char *kwnames[] = {
45823 (char *) "self",(char *) "otherW", NULL
45824 };
45825
45826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45828 if (SWIG_arg_fail(1)) SWIG_fail;
45829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45830 if (SWIG_arg_fail(2)) SWIG_fail;
45831 {
45832 PyThreadState* __tstate = wxPyBeginAllowThreads();
45833 result = (bool)(arg1)->ResetIfWin(arg2);
45834
45835 wxPyEndAllowThreads(__tstate);
45836 if (PyErr_Occurred()) SWIG_fail;
45837 }
45838 {
45839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45840 }
45841 return resultobj;
45842 fail:
45843 return NULL;
45844 }
45845
45846
45847 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45848 PyObject *resultobj = NULL;
45849 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45850 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45851 wxWindow *arg3 = (wxWindow *) 0 ;
45852 bool result;
45853 PyObject * obj0 = 0 ;
45854 PyObject * obj1 = 0 ;
45855 PyObject * obj2 = 0 ;
45856 char *kwnames[] = {
45857 (char *) "self",(char *) "constraints",(char *) "win", NULL
45858 };
45859
45860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45862 if (SWIG_arg_fail(1)) SWIG_fail;
45863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45864 if (SWIG_arg_fail(2)) SWIG_fail;
45865 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45866 if (SWIG_arg_fail(3)) SWIG_fail;
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45870
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 {
45875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45876 }
45877 return resultobj;
45878 fail:
45879 return NULL;
45880 }
45881
45882
45883 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45884 PyObject *resultobj = NULL;
45885 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45886 wxEdge arg2 ;
45887 wxWindow *arg3 = (wxWindow *) 0 ;
45888 wxWindow *arg4 = (wxWindow *) 0 ;
45889 int result;
45890 PyObject * obj0 = 0 ;
45891 PyObject * obj1 = 0 ;
45892 PyObject * obj2 = 0 ;
45893 PyObject * obj3 = 0 ;
45894 char *kwnames[] = {
45895 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45896 };
45897
45898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45900 if (SWIG_arg_fail(1)) SWIG_fail;
45901 {
45902 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45903 if (SWIG_arg_fail(2)) SWIG_fail;
45904 }
45905 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45906 if (SWIG_arg_fail(3)) SWIG_fail;
45907 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45908 if (SWIG_arg_fail(4)) SWIG_fail;
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
45912
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 {
45917 resultobj = SWIG_From_int(static_cast<int >(result));
45918 }
45919 return resultobj;
45920 fail:
45921 return NULL;
45922 }
45923
45924
45925 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45926 PyObject *obj;
45927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45928 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45929 Py_INCREF(obj);
45930 return Py_BuildValue((char *)"");
45931 }
45932 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45933 PyObject *resultobj = NULL;
45934 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45935 wxIndividualLayoutConstraint *result;
45936 PyObject * obj0 = 0 ;
45937 char *kwnames[] = {
45938 (char *) "self", NULL
45939 };
45940
45941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45943 if (SWIG_arg_fail(1)) SWIG_fail;
45944 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45945
45946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45947 return resultobj;
45948 fail:
45949 return NULL;
45950 }
45951
45952
45953 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45954 PyObject *resultobj = NULL;
45955 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45956 wxIndividualLayoutConstraint *result;
45957 PyObject * obj0 = 0 ;
45958 char *kwnames[] = {
45959 (char *) "self", NULL
45960 };
45961
45962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45964 if (SWIG_arg_fail(1)) SWIG_fail;
45965 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45966
45967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45968 return resultobj;
45969 fail:
45970 return NULL;
45971 }
45972
45973
45974 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45975 PyObject *resultobj = NULL;
45976 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45977 wxIndividualLayoutConstraint *result;
45978 PyObject * obj0 = 0 ;
45979 char *kwnames[] = {
45980 (char *) "self", NULL
45981 };
45982
45983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45985 if (SWIG_arg_fail(1)) SWIG_fail;
45986 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45987
45988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45989 return resultobj;
45990 fail:
45991 return NULL;
45992 }
45993
45994
45995 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45996 PyObject *resultobj = NULL;
45997 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45998 wxIndividualLayoutConstraint *result;
45999 PyObject * obj0 = 0 ;
46000 char *kwnames[] = {
46001 (char *) "self", NULL
46002 };
46003
46004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46006 if (SWIG_arg_fail(1)) SWIG_fail;
46007 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46008
46009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46010 return resultobj;
46011 fail:
46012 return NULL;
46013 }
46014
46015
46016 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46017 PyObject *resultobj = NULL;
46018 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46019 wxIndividualLayoutConstraint *result;
46020 PyObject * obj0 = 0 ;
46021 char *kwnames[] = {
46022 (char *) "self", NULL
46023 };
46024
46025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46027 if (SWIG_arg_fail(1)) SWIG_fail;
46028 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46029
46030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46031 return resultobj;
46032 fail:
46033 return NULL;
46034 }
46035
46036
46037 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46038 PyObject *resultobj = NULL;
46039 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46040 wxIndividualLayoutConstraint *result;
46041 PyObject * obj0 = 0 ;
46042 char *kwnames[] = {
46043 (char *) "self", NULL
46044 };
46045
46046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46048 if (SWIG_arg_fail(1)) SWIG_fail;
46049 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46050
46051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46052 return resultobj;
46053 fail:
46054 return NULL;
46055 }
46056
46057
46058 static PyObject *_wrap_LayoutConstraints_centreX_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_centreX_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)->centreX);
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_centreY_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_centreY_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)->centreY);
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_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46101 PyObject *resultobj = NULL;
46102 wxLayoutConstraints *result;
46103 char *kwnames[] = {
46104 NULL
46105 };
46106
46107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46108 {
46109 PyThreadState* __tstate = wxPyBeginAllowThreads();
46110 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46111
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46123 PyObject *resultobj = NULL;
46124 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46125 wxWindow *arg2 = (wxWindow *) 0 ;
46126 int *arg3 = (int *) 0 ;
46127 bool result;
46128 int temp3 ;
46129 int res3 = 0 ;
46130 PyObject * obj0 = 0 ;
46131 PyObject * obj1 = 0 ;
46132 char *kwnames[] = {
46133 (char *) "self",(char *) "win", NULL
46134 };
46135
46136 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46139 if (SWIG_arg_fail(1)) SWIG_fail;
46140 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46141 if (SWIG_arg_fail(2)) SWIG_fail;
46142 {
46143 PyThreadState* __tstate = wxPyBeginAllowThreads();
46144 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46145
46146 wxPyEndAllowThreads(__tstate);
46147 if (PyErr_Occurred()) SWIG_fail;
46148 }
46149 {
46150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46151 }
46152 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46153 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46154 return resultobj;
46155 fail:
46156 return NULL;
46157 }
46158
46159
46160 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46161 PyObject *resultobj = NULL;
46162 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46163 bool result;
46164 PyObject * obj0 = 0 ;
46165 char *kwnames[] = {
46166 (char *) "self", NULL
46167 };
46168
46169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46171 if (SWIG_arg_fail(1)) SWIG_fail;
46172 {
46173 PyThreadState* __tstate = wxPyBeginAllowThreads();
46174 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46175
46176 wxPyEndAllowThreads(__tstate);
46177 if (PyErr_Occurred()) SWIG_fail;
46178 }
46179 {
46180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46181 }
46182 return resultobj;
46183 fail:
46184 return NULL;
46185 }
46186
46187
46188 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46189 PyObject *obj;
46190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46191 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46192 Py_INCREF(obj);
46193 return Py_BuildValue((char *)"");
46194 }
46195 static PyMethodDef SwigMethods[] = {
46196 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46197 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46198 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46201 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46222 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46235 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46250 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46304 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46332 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46351 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46353 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46361 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46362 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46374 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46386 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46390 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46396 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46406 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46419 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46426 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46434 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46442 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46526 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46528 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46530 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46532 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46534 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46536 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46538 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46540 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46544 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46546 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46548 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46550 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46564 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46582 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46585 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46588 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46600 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46605 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46611 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46617 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46680 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46687 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46723 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46733 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46739 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46741 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46743 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46746 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46750 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46753 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46756 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46758 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46763 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46771 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46775 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46778 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46780 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46784 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46801 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46803 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46806 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46808 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46812 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46816 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46827 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46830 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46833 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46837 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46844 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46849 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46854 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46858 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46903 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46923 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
46926 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46933 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46937 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46947 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47118 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47160 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47175 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47178 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47233 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47262 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47306 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47314 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47333 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47334 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47372 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47402 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47405 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47409 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47412 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47422 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47434 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47446 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47456 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47466 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47480 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47487 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47488 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47489 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47490 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47491 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47496 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47516 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47518 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47519 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47521 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47523 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47529 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47530 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47531 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47533 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47535 { NULL, NULL, 0, NULL }
47536 };
47537
47538
47539 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47540
47541 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47542 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47543 }
47544 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47545 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47546 }
47547 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47548 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47549 }
47550 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47551 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47552 }
47553 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47554 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47555 }
47556 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47557 return (void *)((wxSizer *) ((wxGridSizer *) x));
47558 }
47559 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47560 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47561 }
47562 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47563 return (void *)((wxSizer *) ((wxPySizer *) x));
47564 }
47565 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47566 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47567 }
47568 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47569 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47570 }
47571 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47572 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47573 }
47574 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47575 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47576 }
47577 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47578 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47579 }
47580 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47581 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47582 }
47583 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47584 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47585 }
47586 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47587 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47588 }
47589 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47590 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47591 }
47592 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47593 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47594 }
47595 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47596 return (void *)((wxEvent *) ((wxPyEvent *) x));
47597 }
47598 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47599 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47600 }
47601 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47602 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47603 }
47604 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47605 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47606 }
47607 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47608 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47609 }
47610 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47611 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47612 }
47613 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47614 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47615 }
47616 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47617 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47618 }
47619 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47620 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47621 }
47622 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47623 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47624 }
47625 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47626 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47627 }
47628 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47629 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47630 }
47631 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47632 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47633 }
47634 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47635 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47636 }
47637 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47638 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47639 }
47640 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47641 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47642 }
47643 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47644 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47645 }
47646 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47647 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47648 }
47649 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47650 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47651 }
47652 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47653 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47654 }
47655 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47656 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47657 }
47658 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47659 return (void *)((wxEvent *) ((wxShowEvent *) x));
47660 }
47661 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47662 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47663 }
47664 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47665 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47666 }
47667 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47668 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47669 }
47670 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47671 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47672 }
47673 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47674 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47675 }
47676 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47677 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47678 }
47679 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47680 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47681 }
47682 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47683 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47684 }
47685 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47686 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47687 }
47688 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47689 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47690 }
47691 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47692 return (void *)((wxControl *) ((wxControlWithItems *) x));
47693 }
47694 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47695 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47696 }
47697 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47698 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47699 }
47700 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47701 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47702 }
47703 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47704 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47705 }
47706 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47707 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47708 }
47709 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47710 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47711 }
47712 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47713 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47714 }
47715 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47716 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47717 }
47718 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47719 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47720 }
47721 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47722 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47723 }
47724 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47725 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47726 }
47727 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47728 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47729 }
47730 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47731 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47732 }
47733 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47734 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47735 }
47736 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47737 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47738 }
47739 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47740 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47741 }
47742 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47743 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47744 }
47745 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47746 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47747 }
47748 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47749 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47750 }
47751 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47752 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47753 }
47754 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47755 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47756 }
47757 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47758 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47759 }
47760 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47761 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47762 }
47763 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47764 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47765 }
47766 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47767 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47768 }
47769 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47770 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47771 }
47772 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47773 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47774 }
47775 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47776 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47777 }
47778 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47779 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47780 }
47781 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47782 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47783 }
47784 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47785 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47786 }
47787 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47788 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47789 }
47790 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47791 return (void *)((wxObject *) ((wxSizerItem *) x));
47792 }
47793 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47794 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47795 }
47796 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47797 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47798 }
47799 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47800 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47801 }
47802 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47803 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47804 }
47805 static void *_p_wxSizerTo_p_wxObject(void *x) {
47806 return (void *)((wxObject *) ((wxSizer *) x));
47807 }
47808 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47809 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47810 }
47811 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47812 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47813 }
47814 static void *_p_wxEventTo_p_wxObject(void *x) {
47815 return (void *)((wxObject *) ((wxEvent *) x));
47816 }
47817 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47818 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47819 }
47820 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47821 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47822 }
47823 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47824 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47825 }
47826 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47827 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47828 }
47829 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47830 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47831 }
47832 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47833 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47834 }
47835 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47836 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47837 }
47838 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47839 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47840 }
47841 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47842 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47843 }
47844 static void *_p_wxControlTo_p_wxObject(void *x) {
47845 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47846 }
47847 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47848 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47849 }
47850 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47851 return (void *)((wxObject *) ((wxFSFile *) x));
47852 }
47853 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47854 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47855 }
47856 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47857 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47858 }
47859 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47860 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47861 }
47862 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47863 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47864 }
47865 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47866 return (void *)((wxObject *) ((wxMenuItem *) x));
47867 }
47868 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47869 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47870 }
47871 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47872 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47873 }
47874 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47875 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47876 }
47877 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47878 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47879 }
47880 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47881 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47882 }
47883 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47884 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47885 }
47886 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47887 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47888 }
47889 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47890 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47891 }
47892 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47893 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47894 }
47895 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47896 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47897 }
47898 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47899 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47900 }
47901 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47902 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47903 }
47904 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47905 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47906 }
47907 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47908 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47909 }
47910 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47911 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47912 }
47913 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47914 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47915 }
47916 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47917 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47918 }
47919 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47920 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47921 }
47922 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47923 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47924 }
47925 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47926 return (void *)((wxObject *) ((wxImageHandler *) x));
47927 }
47928 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47929 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47930 }
47931 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47932 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47933 }
47934 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47935 return (void *)((wxObject *) ((wxEvtHandler *) x));
47936 }
47937 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47938 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47939 }
47940 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47941 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47942 }
47943 static void *_p_wxImageTo_p_wxObject(void *x) {
47944 return (void *)((wxObject *) ((wxImage *) x));
47945 }
47946 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47947 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47948 }
47949 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47950 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47951 }
47952 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47953 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47954 }
47955 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47956 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47957 }
47958 static void *_p_wxWindowTo_p_wxObject(void *x) {
47959 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47960 }
47961 static void *_p_wxMenuTo_p_wxObject(void *x) {
47962 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47963 }
47964 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47965 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47966 }
47967 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47968 return (void *)((wxObject *) ((wxFileSystem *) x));
47969 }
47970 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47971 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47972 }
47973 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47974 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47975 }
47976 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47977 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47978 }
47979 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47980 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47981 }
47982 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47983 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47984 }
47985 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47986 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47987 }
47988 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47989 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47990 }
47991 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47992 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47993 }
47994 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47995 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47996 }
47997 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47998 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47999 }
48000 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48001 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48002 }
48003 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48004 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48005 }
48006 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48007 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48008 }
48009 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48010 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48011 }
48012 static void *_p_wxControlTo_p_wxWindow(void *x) {
48013 return (void *)((wxWindow *) ((wxControl *) x));
48014 }
48015 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48016 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48017 }
48018 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48019 return (void *)((wxWindow *) ((wxMenuBar *) x));
48020 }
48021 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48022 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48023 }
48024 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48025 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48026 }
48027 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48028 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48029 }
48030 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48031 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48032 }
48033 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48034 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48035 }
48036 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48037 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48038 }
48039 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48040 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48041 }
48042 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48043 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48044 }
48045 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48046 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48047 }
48048 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48049 return (void *)((wxValidator *) ((wxPyValidator *) x));
48050 }
48051 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48052 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48053 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48054 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48055 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48056 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48057 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48058 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48059 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48060 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48061 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48062 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48063 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48064 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48065 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48066 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48067 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48068 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48069 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48070 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48071 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48072 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48073 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48074 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48075 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48076 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48077 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48078 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48079 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48080 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48081 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48082 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48083 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48084 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48085 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48086 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48087 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48088 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48089 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48090 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48091 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48092 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48093 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48094 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48095 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48096 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48097 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48098 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48099 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48100 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48101 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48102 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48103 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48104 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48105 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48106 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48107 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48108 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48109 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48110 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48111 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48112 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48113 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48114 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48115 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48116 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48117 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48118 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48119 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48120 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48121 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48122 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48123 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48124 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48125 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48126 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48127 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48128 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48129 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48130 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48131 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48132 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48133 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48134 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48135 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48136 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48137 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48138 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48139 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48140 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48141 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48142 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48143 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48144 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48145 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48146 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48147 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48148 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48149 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48150 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48151 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48152 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48153 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48154 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48155 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48156 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48157 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48158 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48159 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48160 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48161 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48162 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48163 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48164 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48165 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48166 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48167 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48168 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48169 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48170 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48171 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48172 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48173 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48174 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48175 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48176 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48177 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48178 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48179 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48180 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48181 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48182 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48183
48184 static swig_type_info *swig_type_initial[] = {
48185 &_swigt__p_buffer,
48186 &_swigt__p_char,
48187 &_swigt__p_form_ops_t,
48188 &_swigt__p_int,
48189 &_swigt__p_long,
48190 &_swigt__p_unsigned_char,
48191 &_swigt__p_unsigned_int,
48192 &_swigt__p_unsigned_long,
48193 &_swigt__p_wxANIHandler,
48194 &_swigt__p_wxAcceleratorEntry,
48195 &_swigt__p_wxAcceleratorTable,
48196 &_swigt__p_wxActivateEvent,
48197 &_swigt__p_wxAppTraits,
48198 &_swigt__p_wxArrayString,
48199 &_swigt__p_wxBMPHandler,
48200 &_swigt__p_wxBitmap,
48201 &_swigt__p_wxBoxSizer,
48202 &_swigt__p_wxButton,
48203 &_swigt__p_wxCURHandler,
48204 &_swigt__p_wxCaret,
48205 &_swigt__p_wxChildFocusEvent,
48206 &_swigt__p_wxCloseEvent,
48207 &_swigt__p_wxColour,
48208 &_swigt__p_wxCommandEvent,
48209 &_swigt__p_wxContextMenuEvent,
48210 &_swigt__p_wxControl,
48211 &_swigt__p_wxControlWithItems,
48212 &_swigt__p_wxCursor,
48213 &_swigt__p_wxDC,
48214 &_swigt__p_wxDateEvent,
48215 &_swigt__p_wxDateTime,
48216 &_swigt__p_wxDisplayChangedEvent,
48217 &_swigt__p_wxDropFilesEvent,
48218 &_swigt__p_wxDuplexMode,
48219 &_swigt__p_wxEraseEvent,
48220 &_swigt__p_wxEvent,
48221 &_swigt__p_wxEventLoop,
48222 &_swigt__p_wxEventLoopActivator,
48223 &_swigt__p_wxEvtHandler,
48224 &_swigt__p_wxFSFile,
48225 &_swigt__p_wxFileSystem,
48226 &_swigt__p_wxFileSystemHandler,
48227 &_swigt__p_wxFlexGridSizer,
48228 &_swigt__p_wxFocusEvent,
48229 &_swigt__p_wxFont,
48230 &_swigt__p_wxFrame,
48231 &_swigt__p_wxGBPosition,
48232 &_swigt__p_wxGBSizerItem,
48233 &_swigt__p_wxGBSpan,
48234 &_swigt__p_wxGIFHandler,
48235 &_swigt__p_wxGridBagSizer,
48236 &_swigt__p_wxGridSizer,
48237 &_swigt__p_wxICOHandler,
48238 &_swigt__p_wxIconizeEvent,
48239 &_swigt__p_wxIdleEvent,
48240 &_swigt__p_wxImage,
48241 &_swigt__p_wxImageHandler,
48242 &_swigt__p_wxImageHistogram,
48243 &_swigt__p_wxImage_HSVValue,
48244 &_swigt__p_wxImage_RGBValue,
48245 &_swigt__p_wxIndividualLayoutConstraint,
48246 &_swigt__p_wxInitDialogEvent,
48247 &_swigt__p_wxInputStream,
48248 &_swigt__p_wxInternetFSHandler,
48249 &_swigt__p_wxItemContainer,
48250 &_swigt__p_wxJPEGHandler,
48251 &_swigt__p_wxKeyEvent,
48252 &_swigt__p_wxLayoutConstraints,
48253 &_swigt__p_wxMaximizeEvent,
48254 &_swigt__p_wxMemoryFSHandler,
48255 &_swigt__p_wxMenu,
48256 &_swigt__p_wxMenuBar,
48257 &_swigt__p_wxMenuBarBase,
48258 &_swigt__p_wxMenuEvent,
48259 &_swigt__p_wxMenuItem,
48260 &_swigt__p_wxMouseCaptureChangedEvent,
48261 &_swigt__p_wxMouseEvent,
48262 &_swigt__p_wxMoveEvent,
48263 &_swigt__p_wxNavigationKeyEvent,
48264 &_swigt__p_wxNcPaintEvent,
48265 &_swigt__p_wxNotifyEvent,
48266 &_swigt__p_wxObject,
48267 &_swigt__p_wxOutputStream,
48268 &_swigt__p_wxPCXHandler,
48269 &_swigt__p_wxPNGHandler,
48270 &_swigt__p_wxPNMHandler,
48271 &_swigt__p_wxPaintEvent,
48272 &_swigt__p_wxPaletteChangedEvent,
48273 &_swigt__p_wxPaperSize,
48274 &_swigt__p_wxPoint,
48275 &_swigt__p_wxPoint2D,
48276 &_swigt__p_wxPropagateOnce,
48277 &_swigt__p_wxPropagationDisabler,
48278 &_swigt__p_wxPyApp,
48279 &_swigt__p_wxPyCommandEvent,
48280 &_swigt__p_wxPyDropTarget,
48281 &_swigt__p_wxPyEvent,
48282 &_swigt__p_wxPyFileSystemHandler,
48283 &_swigt__p_wxPyImageHandler,
48284 &_swigt__p_wxPyInputStream,
48285 &_swigt__p_wxPySizer,
48286 &_swigt__p_wxPyValidator,
48287 &_swigt__p_wxQuantize,
48288 &_swigt__p_wxQueryNewPaletteEvent,
48289 &_swigt__p_wxRealPoint,
48290 &_swigt__p_wxRect,
48291 &_swigt__p_wxRegion,
48292 &_swigt__p_wxScrollEvent,
48293 &_swigt__p_wxScrollWinEvent,
48294 &_swigt__p_wxSetCursorEvent,
48295 &_swigt__p_wxShowEvent,
48296 &_swigt__p_wxSize,
48297 &_swigt__p_wxSizeEvent,
48298 &_swigt__p_wxSizer,
48299 &_swigt__p_wxSizerItem,
48300 &_swigt__p_wxStaticBox,
48301 &_swigt__p_wxStaticBoxSizer,
48302 &_swigt__p_wxStdDialogButtonSizer,
48303 &_swigt__p_wxSysColourChangedEvent,
48304 &_swigt__p_wxTIFFHandler,
48305 &_swigt__p_wxToolTip,
48306 &_swigt__p_wxUpdateUIEvent,
48307 &_swigt__p_wxValidator,
48308 &_swigt__p_wxVisualAttributes,
48309 &_swigt__p_wxWindow,
48310 &_swigt__p_wxWindowCreateEvent,
48311 &_swigt__p_wxWindowDestroyEvent,
48312 &_swigt__p_wxXPMHandler,
48313 &_swigt__p_wxZipFSHandler,
48314 &_swigt__ptrdiff_t,
48315 &_swigt__std__ptrdiff_t,
48316 &_swigt__unsigned_int,
48317 };
48318
48319 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48320 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48321 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48322 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48323 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48324 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48325 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48326 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48327 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48328 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48329 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48330 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48331 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48332 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48333 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}};
48334 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48335 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}};
48336 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48337 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}};
48338 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48339 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48340 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48341 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48342 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}};
48343 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48344 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}};
48345 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48346 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48347 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48348 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48349 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48350 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48351 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48352 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48353 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48354 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}};
48355 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48356 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48357 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}};
48358 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48359 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48360 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}};
48361 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}};
48362 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48363 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48364 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48365 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48366 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48367 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48368 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48369 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48370 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}};
48371 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}};
48372 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48373 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48374 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48375 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}};
48376 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48377 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48378 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48379 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48380 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48381 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48382 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48383 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}};
48384 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48385 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48386 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48387 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48388 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48389 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48390 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48391 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48392 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48393 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48394 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48395 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48396 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48397 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48398 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48399 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48400 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}};
48401 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48402 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48403 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48404 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48405 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48406 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48407 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48408 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48409 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48410 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48411 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48412 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48413 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48414 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48415 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48416 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48417 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48418 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48419 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48420 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48421 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48422 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48423 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48424 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48425 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48426 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48427 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48428 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48429 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48430 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48431 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48432 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}};
48433 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}};
48434 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48435 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48436 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48437 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48438 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48439 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48440 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48441 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}};
48442 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48443 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}};
48444 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48445 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48446 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48447 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48448 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48449 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48450 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48451
48452 static swig_cast_info *swig_cast_initial[] = {
48453 _swigc__p_buffer,
48454 _swigc__p_char,
48455 _swigc__p_form_ops_t,
48456 _swigc__p_int,
48457 _swigc__p_long,
48458 _swigc__p_unsigned_char,
48459 _swigc__p_unsigned_int,
48460 _swigc__p_unsigned_long,
48461 _swigc__p_wxANIHandler,
48462 _swigc__p_wxAcceleratorEntry,
48463 _swigc__p_wxAcceleratorTable,
48464 _swigc__p_wxActivateEvent,
48465 _swigc__p_wxAppTraits,
48466 _swigc__p_wxArrayString,
48467 _swigc__p_wxBMPHandler,
48468 _swigc__p_wxBitmap,
48469 _swigc__p_wxBoxSizer,
48470 _swigc__p_wxButton,
48471 _swigc__p_wxCURHandler,
48472 _swigc__p_wxCaret,
48473 _swigc__p_wxChildFocusEvent,
48474 _swigc__p_wxCloseEvent,
48475 _swigc__p_wxColour,
48476 _swigc__p_wxCommandEvent,
48477 _swigc__p_wxContextMenuEvent,
48478 _swigc__p_wxControl,
48479 _swigc__p_wxControlWithItems,
48480 _swigc__p_wxCursor,
48481 _swigc__p_wxDC,
48482 _swigc__p_wxDateEvent,
48483 _swigc__p_wxDateTime,
48484 _swigc__p_wxDisplayChangedEvent,
48485 _swigc__p_wxDropFilesEvent,
48486 _swigc__p_wxDuplexMode,
48487 _swigc__p_wxEraseEvent,
48488 _swigc__p_wxEvent,
48489 _swigc__p_wxEventLoop,
48490 _swigc__p_wxEventLoopActivator,
48491 _swigc__p_wxEvtHandler,
48492 _swigc__p_wxFSFile,
48493 _swigc__p_wxFileSystem,
48494 _swigc__p_wxFileSystemHandler,
48495 _swigc__p_wxFlexGridSizer,
48496 _swigc__p_wxFocusEvent,
48497 _swigc__p_wxFont,
48498 _swigc__p_wxFrame,
48499 _swigc__p_wxGBPosition,
48500 _swigc__p_wxGBSizerItem,
48501 _swigc__p_wxGBSpan,
48502 _swigc__p_wxGIFHandler,
48503 _swigc__p_wxGridBagSizer,
48504 _swigc__p_wxGridSizer,
48505 _swigc__p_wxICOHandler,
48506 _swigc__p_wxIconizeEvent,
48507 _swigc__p_wxIdleEvent,
48508 _swigc__p_wxImage,
48509 _swigc__p_wxImageHandler,
48510 _swigc__p_wxImageHistogram,
48511 _swigc__p_wxImage_HSVValue,
48512 _swigc__p_wxImage_RGBValue,
48513 _swigc__p_wxIndividualLayoutConstraint,
48514 _swigc__p_wxInitDialogEvent,
48515 _swigc__p_wxInputStream,
48516 _swigc__p_wxInternetFSHandler,
48517 _swigc__p_wxItemContainer,
48518 _swigc__p_wxJPEGHandler,
48519 _swigc__p_wxKeyEvent,
48520 _swigc__p_wxLayoutConstraints,
48521 _swigc__p_wxMaximizeEvent,
48522 _swigc__p_wxMemoryFSHandler,
48523 _swigc__p_wxMenu,
48524 _swigc__p_wxMenuBar,
48525 _swigc__p_wxMenuBarBase,
48526 _swigc__p_wxMenuEvent,
48527 _swigc__p_wxMenuItem,
48528 _swigc__p_wxMouseCaptureChangedEvent,
48529 _swigc__p_wxMouseEvent,
48530 _swigc__p_wxMoveEvent,
48531 _swigc__p_wxNavigationKeyEvent,
48532 _swigc__p_wxNcPaintEvent,
48533 _swigc__p_wxNotifyEvent,
48534 _swigc__p_wxObject,
48535 _swigc__p_wxOutputStream,
48536 _swigc__p_wxPCXHandler,
48537 _swigc__p_wxPNGHandler,
48538 _swigc__p_wxPNMHandler,
48539 _swigc__p_wxPaintEvent,
48540 _swigc__p_wxPaletteChangedEvent,
48541 _swigc__p_wxPaperSize,
48542 _swigc__p_wxPoint,
48543 _swigc__p_wxPoint2D,
48544 _swigc__p_wxPropagateOnce,
48545 _swigc__p_wxPropagationDisabler,
48546 _swigc__p_wxPyApp,
48547 _swigc__p_wxPyCommandEvent,
48548 _swigc__p_wxPyDropTarget,
48549 _swigc__p_wxPyEvent,
48550 _swigc__p_wxPyFileSystemHandler,
48551 _swigc__p_wxPyImageHandler,
48552 _swigc__p_wxPyInputStream,
48553 _swigc__p_wxPySizer,
48554 _swigc__p_wxPyValidator,
48555 _swigc__p_wxQuantize,
48556 _swigc__p_wxQueryNewPaletteEvent,
48557 _swigc__p_wxRealPoint,
48558 _swigc__p_wxRect,
48559 _swigc__p_wxRegion,
48560 _swigc__p_wxScrollEvent,
48561 _swigc__p_wxScrollWinEvent,
48562 _swigc__p_wxSetCursorEvent,
48563 _swigc__p_wxShowEvent,
48564 _swigc__p_wxSize,
48565 _swigc__p_wxSizeEvent,
48566 _swigc__p_wxSizer,
48567 _swigc__p_wxSizerItem,
48568 _swigc__p_wxStaticBox,
48569 _swigc__p_wxStaticBoxSizer,
48570 _swigc__p_wxStdDialogButtonSizer,
48571 _swigc__p_wxSysColourChangedEvent,
48572 _swigc__p_wxTIFFHandler,
48573 _swigc__p_wxToolTip,
48574 _swigc__p_wxUpdateUIEvent,
48575 _swigc__p_wxValidator,
48576 _swigc__p_wxVisualAttributes,
48577 _swigc__p_wxWindow,
48578 _swigc__p_wxWindowCreateEvent,
48579 _swigc__p_wxWindowDestroyEvent,
48580 _swigc__p_wxXPMHandler,
48581 _swigc__p_wxZipFSHandler,
48582 _swigc__ptrdiff_t,
48583 _swigc__std__ptrdiff_t,
48584 _swigc__unsigned_int,
48585 };
48586
48587
48588 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48589
48590 static swig_const_info swig_const_table[] = {
48591 {0, 0, 0, 0.0, 0, 0}};
48592
48593 #ifdef __cplusplus
48594 }
48595 #endif
48596 /*************************************************************************
48597 * Type initialization:
48598 * This problem is tough by the requirement that no dynamic
48599 * memory is used. Also, since swig_type_info structures store pointers to
48600 * swig_cast_info structures and swig_cast_info structures store pointers back
48601 * to swig_type_info structures, we need some lookup code at initialization.
48602 * The idea is that swig generates all the structures that are needed.
48603 * The runtime then collects these partially filled structures.
48604 * The SWIG_InitializeModule function takes these initial arrays out of
48605 * swig_module, and does all the lookup, filling in the swig_module.types
48606 * array with the correct data and linking the correct swig_cast_info
48607 * structures together.
48608
48609 * The generated swig_type_info structures are assigned staticly to an initial
48610 * array. We just loop though that array, and handle each type individually.
48611 * First we lookup if this type has been already loaded, and if so, use the
48612 * loaded structure instead of the generated one. Then we have to fill in the
48613 * cast linked list. The cast data is initially stored in something like a
48614 * two-dimensional array. Each row corresponds to a type (there are the same
48615 * number of rows as there are in the swig_type_initial array). Each entry in
48616 * a column is one of the swig_cast_info structures for that type.
48617 * The cast_initial array is actually an array of arrays, because each row has
48618 * a variable number of columns. So to actually build the cast linked list,
48619 * we find the array of casts associated with the type, and loop through it
48620 * adding the casts to the list. The one last trick we need to do is making
48621 * sure the type pointer in the swig_cast_info struct is correct.
48622
48623 * First off, we lookup the cast->type name to see if it is already loaded.
48624 * There are three cases to handle:
48625 * 1) If the cast->type has already been loaded AND the type we are adding
48626 * casting info to has not been loaded (it is in this module), THEN we
48627 * replace the cast->type pointer with the type pointer that has already
48628 * been loaded.
48629 * 2) If BOTH types (the one we are adding casting info to, and the
48630 * cast->type) are loaded, THEN the cast info has already been loaded by
48631 * the previous module so we just ignore it.
48632 * 3) Finally, if cast->type has not already been loaded, then we add that
48633 * swig_cast_info to the linked list (because the cast->type) pointer will
48634 * be correct.
48635 **/
48636
48637 #ifdef __cplusplus
48638 extern "C" {
48639 #if 0
48640 } /* c-mode */
48641 #endif
48642 #endif
48643
48644 #if 0
48645 #define SWIGRUNTIME_DEBUG
48646 #endif
48647
48648 SWIGRUNTIME void
48649 SWIG_InitializeModule(void *clientdata) {
48650 size_t i;
48651 swig_module_info *module_head;
48652 static int init_run = 0;
48653
48654 clientdata = clientdata;
48655
48656 if (init_run) return;
48657 init_run = 1;
48658
48659 /* Initialize the swig_module */
48660 swig_module.type_initial = swig_type_initial;
48661 swig_module.cast_initial = swig_cast_initial;
48662
48663 /* Try and load any already created modules */
48664 module_head = SWIG_GetModule(clientdata);
48665 if (module_head) {
48666 swig_module.next = module_head->next;
48667 module_head->next = &swig_module;
48668 } else {
48669 /* This is the first module loaded */
48670 swig_module.next = &swig_module;
48671 SWIG_SetModule(clientdata, &swig_module);
48672 }
48673
48674 /* Now work on filling in swig_module.types */
48675 #ifdef SWIGRUNTIME_DEBUG
48676 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48677 #endif
48678 for (i = 0; i < swig_module.size; ++i) {
48679 swig_type_info *type = 0;
48680 swig_type_info *ret;
48681 swig_cast_info *cast;
48682
48683 #ifdef SWIGRUNTIME_DEBUG
48684 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48685 #endif
48686
48687 /* if there is another module already loaded */
48688 if (swig_module.next != &swig_module) {
48689 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48690 }
48691 if (type) {
48692 /* Overwrite clientdata field */
48693 #ifdef SWIGRUNTIME_DEBUG
48694 printf("SWIG_InitializeModule: found type %s\n", type->name);
48695 #endif
48696 if (swig_module.type_initial[i]->clientdata) {
48697 type->clientdata = swig_module.type_initial[i]->clientdata;
48698 #ifdef SWIGRUNTIME_DEBUG
48699 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48700 #endif
48701 }
48702 } else {
48703 type = swig_module.type_initial[i];
48704 }
48705
48706 /* Insert casting types */
48707 cast = swig_module.cast_initial[i];
48708 while (cast->type) {
48709 /* Don't need to add information already in the list */
48710 ret = 0;
48711 #ifdef SWIGRUNTIME_DEBUG
48712 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48713 #endif
48714 if (swig_module.next != &swig_module) {
48715 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48716 #ifdef SWIGRUNTIME_DEBUG
48717 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48718 #endif
48719 }
48720 if (ret) {
48721 if (type == swig_module.type_initial[i]) {
48722 #ifdef SWIGRUNTIME_DEBUG
48723 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48724 #endif
48725 cast->type = ret;
48726 ret = 0;
48727 } else {
48728 /* Check for casting already in the list */
48729 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48730 #ifdef SWIGRUNTIME_DEBUG
48731 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48732 #endif
48733 if (!ocast) ret = 0;
48734 }
48735 }
48736
48737 if (!ret) {
48738 #ifdef SWIGRUNTIME_DEBUG
48739 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48740 #endif
48741 if (type->cast) {
48742 type->cast->prev = cast;
48743 cast->next = type->cast;
48744 }
48745 type->cast = cast;
48746 }
48747 cast++;
48748 }
48749 /* Set entry in modules->types array equal to the type */
48750 swig_module.types[i] = type;
48751 }
48752 swig_module.types[i] = 0;
48753
48754 #ifdef SWIGRUNTIME_DEBUG
48755 printf("**** SWIG_InitializeModule: Cast List ******\n");
48756 for (i = 0; i < swig_module.size; ++i) {
48757 int j = 0;
48758 swig_cast_info *cast = swig_module.cast_initial[i];
48759 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48760 while (cast->type) {
48761 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48762 cast++;
48763 ++j;
48764 }
48765 printf("---- Total casts: %d\n",j);
48766 }
48767 printf("**** SWIG_InitializeModule: Cast List ******\n");
48768 #endif
48769 }
48770
48771 /* This function will propagate the clientdata field of type to
48772 * any new swig_type_info structures that have been added into the list
48773 * of equivalent types. It is like calling
48774 * SWIG_TypeClientData(type, clientdata) a second time.
48775 */
48776 SWIGRUNTIME void
48777 SWIG_PropagateClientData(void) {
48778 size_t i;
48779 swig_cast_info *equiv;
48780 static int init_run = 0;
48781
48782 if (init_run) return;
48783 init_run = 1;
48784
48785 for (i = 0; i < swig_module.size; i++) {
48786 if (swig_module.types[i]->clientdata) {
48787 equiv = swig_module.types[i]->cast;
48788 while (equiv) {
48789 if (!equiv->converter) {
48790 if (equiv->type && !equiv->type->clientdata)
48791 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48792 }
48793 equiv = equiv->next;
48794 }
48795 }
48796 }
48797 }
48798
48799 #ifdef __cplusplus
48800 #if 0
48801 {
48802 /* c-mode */
48803 #endif
48804 }
48805 #endif
48806
48807
48808
48809 #ifdef __cplusplus
48810 extern "C" {
48811 #endif
48812
48813 /* Python-specific SWIG API */
48814 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48815 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48816 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48817
48818 /* -----------------------------------------------------------------------------
48819 * global variable support code.
48820 * ----------------------------------------------------------------------------- */
48821
48822 typedef struct swig_globalvar {
48823 char *name; /* Name of global variable */
48824 PyObject *(*get_attr)(void); /* Return the current value */
48825 int (*set_attr)(PyObject *); /* Set the value */
48826 struct swig_globalvar *next;
48827 } swig_globalvar;
48828
48829 typedef struct swig_varlinkobject {
48830 PyObject_HEAD
48831 swig_globalvar *vars;
48832 } swig_varlinkobject;
48833
48834 SWIGINTERN PyObject *
48835 swig_varlink_repr(swig_varlinkobject *v) {
48836 v = v;
48837 return PyString_FromString("<Swig global variables>");
48838 }
48839
48840 SWIGINTERN int
48841 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48842 swig_globalvar *var;
48843 flags = flags;
48844 fprintf(fp,"Swig global variables { ");
48845 for (var = v->vars; var; var=var->next) {
48846 fprintf(fp,"%s", var->name);
48847 if (var->next) fprintf(fp,", ");
48848 }
48849 fprintf(fp," }\n");
48850 return 0;
48851 }
48852
48853 SWIGINTERN PyObject *
48854 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48855 swig_globalvar *var = v->vars;
48856 while (var) {
48857 if (strcmp(var->name,n) == 0) {
48858 return (*var->get_attr)();
48859 }
48860 var = var->next;
48861 }
48862 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48863 return NULL;
48864 }
48865
48866 SWIGINTERN int
48867 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48868 swig_globalvar *var = v->vars;
48869 while (var) {
48870 if (strcmp(var->name,n) == 0) {
48871 return (*var->set_attr)(p);
48872 }
48873 var = var->next;
48874 }
48875 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48876 return 1;
48877 }
48878
48879 SWIGINTERN PyTypeObject*
48880 swig_varlink_type(void) {
48881 static char varlink__doc__[] = "Swig var link object";
48882 static PyTypeObject varlink_type
48883 #if !defined(__cplusplus)
48884 ;
48885 static int type_init = 0;
48886 if (!type_init) {
48887 PyTypeObject tmp
48888 #endif
48889 = {
48890 PyObject_HEAD_INIT(&PyType_Type)
48891 0, /* Number of items in variable part (ob_size) */
48892 (char *)"swigvarlink", /* Type name (tp_name) */
48893 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48894 0, /* Itemsize (tp_itemsize) */
48895 0, /* Deallocator (tp_dealloc) */
48896 (printfunc) swig_varlink_print, /* Print (tp_print) */
48897 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48898 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48899 0, /* tp_compare */
48900 (reprfunc) swig_varlink_repr, /* tp_repr */
48901 0, /* tp_as_number */
48902 0, /* tp_as_sequence */
48903 0, /* tp_as_mapping */
48904 0, /* tp_hash */
48905 0, /* tp_call */
48906 0, /* tp_str */
48907 0, /* tp_getattro */
48908 0, /* tp_setattro */
48909 0, /* tp_as_buffer */
48910 0, /* tp_flags */
48911 varlink__doc__, /* tp_doc */
48912 #if PY_VERSION_HEX >= 0x02000000
48913 0, /* tp_traverse */
48914 0, /* tp_clear */
48915 #endif
48916 #if PY_VERSION_HEX >= 0x02010000
48917 0, /* tp_richcompare */
48918 0, /* tp_weaklistoffset */
48919 #endif
48920 #if PY_VERSION_HEX >= 0x02020000
48921 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48922 #endif
48923 #if PY_VERSION_HEX >= 0x02030000
48924 0, /* tp_del */
48925 #endif
48926 #ifdef COUNT_ALLOCS
48927 0,0,0,0 /* tp_alloc -> tp_next */
48928 #endif
48929 };
48930 #if !defined(__cplusplus)
48931 varlink_type = tmp;
48932 type_init = 1;
48933 }
48934 #endif
48935 return &varlink_type;
48936 }
48937
48938 /* Create a variable linking object for use later */
48939 SWIGINTERN PyObject *
48940 SWIG_Python_newvarlink(void) {
48941 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
48942 if (result) {
48943 result->vars = 0;
48944 }
48945 return ((PyObject*) result);
48946 }
48947
48948 SWIGINTERN void
48949 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48950 swig_varlinkobject *v = (swig_varlinkobject *) p;
48951 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48952 if (gv) {
48953 size_t size = strlen(name)+1;
48954 gv->name = (char *)malloc(size);
48955 if (gv->name) {
48956 strncpy(gv->name,name,size);
48957 gv->get_attr = get_attr;
48958 gv->set_attr = set_attr;
48959 gv->next = v->vars;
48960 }
48961 }
48962 v->vars = gv;
48963 }
48964
48965 /* -----------------------------------------------------------------------------
48966 * constants/methods manipulation
48967 * ----------------------------------------------------------------------------- */
48968
48969 /* Install Constants */
48970 SWIGINTERN void
48971 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48972 PyObject *obj = 0;
48973 size_t i;
48974 for (i = 0; constants[i].type; ++i) {
48975 switch(constants[i].type) {
48976 case SWIG_PY_INT:
48977 obj = PyInt_FromLong(constants[i].lvalue);
48978 break;
48979 case SWIG_PY_FLOAT:
48980 obj = PyFloat_FromDouble(constants[i].dvalue);
48981 break;
48982 case SWIG_PY_STRING:
48983 if (constants[i].pvalue) {
48984 obj = PyString_FromString((char *) constants[i].pvalue);
48985 } else {
48986 Py_INCREF(Py_None);
48987 obj = Py_None;
48988 }
48989 break;
48990 case SWIG_PY_POINTER:
48991 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48992 break;
48993 case SWIG_PY_BINARY:
48994 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48995 break;
48996 default:
48997 obj = 0;
48998 break;
48999 }
49000 if (obj) {
49001 PyDict_SetItemString(d,constants[i].name,obj);
49002 Py_DECREF(obj);
49003 }
49004 }
49005 }
49006
49007 /* -----------------------------------------------------------------------------*/
49008 /* Fix SwigMethods to carry the callback ptrs when needed */
49009 /* -----------------------------------------------------------------------------*/
49010
49011 SWIGINTERN void
49012 SWIG_Python_FixMethods(PyMethodDef *methods,
49013 swig_const_info *const_table,
49014 swig_type_info **types,
49015 swig_type_info **types_initial) {
49016 size_t i;
49017 for (i = 0; methods[i].ml_name; ++i) {
49018 char *c = methods[i].ml_doc;
49019 if (c && (c = strstr(c, "swig_ptr: "))) {
49020 int j;
49021 swig_const_info *ci = 0;
49022 char *name = c + 10;
49023 for (j = 0; const_table[j].type; ++j) {
49024 if (strncmp(const_table[j].name, name,
49025 strlen(const_table[j].name)) == 0) {
49026 ci = &(const_table[j]);
49027 break;
49028 }
49029 }
49030 if (ci) {
49031 size_t shift = (ci->ptype) - types;
49032 swig_type_info *ty = types_initial[shift];
49033 size_t ldoc = (c - methods[i].ml_doc);
49034 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49035 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49036 if (ndoc) {
49037 char *buff = ndoc;
49038 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49039 if (ptr) {
49040 strncpy(buff, methods[i].ml_doc, ldoc);
49041 buff += ldoc;
49042 strncpy(buff, "swig_ptr: ", 10);
49043 buff += 10;
49044 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49045 methods[i].ml_doc = ndoc;
49046 }
49047 }
49048 }
49049 }
49050 }
49051 }
49052
49053 /* -----------------------------------------------------------------------------*
49054 * Initialize type list
49055 * -----------------------------------------------------------------------------*/
49056
49057 #ifdef __cplusplus
49058 }
49059 #endif
49060
49061 /* -----------------------------------------------------------------------------*
49062 * Partial Init method
49063 * -----------------------------------------------------------------------------*/
49064
49065 #ifdef __cplusplus
49066 extern "C"
49067 #endif
49068 SWIGEXPORT void SWIG_init(void) {
49069 static PyObject *SWIG_globals = 0;
49070 PyObject *m, *d;
49071 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49072
49073 /* Fix SwigMethods to carry the callback ptrs when needed */
49074 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49075
49076 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49077 d = PyModule_GetDict(m);
49078
49079 SWIG_InitializeModule(0);
49080 SWIG_InstallConstants(d,swig_const_table);
49081
49082
49083 #ifndef wxPyUSE_EXPORT
49084 // Make our API structure a CObject so other modules can import it
49085 // from this module.
49086 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49087 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49088 Py_XDECREF(cobj);
49089 #endif
49090
49091 {
49092 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49633 }
49634 {
49635 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49726 }
49727 {
49728 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49729 }
49730 {
49731 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49732 }
49733 {
49734 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49735 }
49736 {
49737 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49738 }
49739 {
49740 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49741 }
49742 {
49743 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49744 }
49745 {
49746 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49747 }
49748 {
49749 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
49834 }
49835 {
49836 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
49837 }
49838 {
49839 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
49840 }
49841 {
49842 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
49873 }
49874 {
49875 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
49906 }
49907 {
49908 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
49915 }
49916 {
49917 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
49918 }
49919 {
49920 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
49921 }
49922 {
49923 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
49924 }
49925 {
49926 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
49927 }
49928 {
49929 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
49930 }
49931 {
49932 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
49933 }
49934 {
49935 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
49936 }
49937 {
49938 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
49939 }
49940 {
49941 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
49942 }
49943 {
49944 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
49945 }
49946 {
49947 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
49948 }
49949 {
49950 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
49951 }
49952 {
49953 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
49954 }
49955 {
49956 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
49957 }
49958 {
49959 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
49960 }
49961 {
49962 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
49963 }
49964 {
49965 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
49966 }
49967 {
49968 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
49969 }
49970 {
49971 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
49972 }
49973 {
49974 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
49975 }
49976 {
49977 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
49978 }
49979 {
49980 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
49981 }
49982 {
49983 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
49984 }
49985 {
49986 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
49987 }
49988 {
49989 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
49990 }
49991 {
49992 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
49993 }
49994 {
49995 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
49996 }
49997 {
49998 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
49999 }
50000 {
50001 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50002 }
50003 {
50004 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50005 }
50006 {
50007 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50008 }
50009 {
50010 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50011 }
50012 {
50013 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50014 }
50015 {
50016 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50017 }
50018 {
50019 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50020 }
50021 {
50022 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50023 }
50024 {
50025 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50026 }
50027 {
50028 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50029 }
50030 {
50031 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50032 }
50033 {
50034 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50035 }
50036 {
50037 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50038 }
50039 {
50040 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50041 }
50042 {
50043 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50044 }
50045 {
50046 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50047 }
50048 {
50049 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50050 }
50051 {
50052 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50053 }
50054 {
50055 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50056 }
50057 {
50058 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50059 }
50060 {
50061 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50062 }
50063 {
50064 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50065 }
50066 {
50067 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50068 }
50069 {
50070 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50071 }
50072 {
50073 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50074 }
50075 {
50076 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50077 }
50078 {
50079 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50080 }
50081 {
50082 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50083 }
50084 {
50085 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50086 }
50087 {
50088 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50089 }
50090 {
50091 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50092 }
50093 {
50094 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50095 }
50096 {
50097 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50098 }
50099 {
50100 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50101 }
50102 {
50103 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50104 }
50105 {
50106 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50107 }
50108 {
50109 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50110 }
50111 {
50112 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50113 }
50114 {
50115 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50116 }
50117 {
50118 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50119 }
50120 {
50121 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50122 }
50123 {
50124 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50125 }
50126 {
50127 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50128 }
50129 {
50130 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50131 }
50132 {
50133 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50134 }
50135 {
50136 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50137 }
50138 {
50139 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50140 }
50141 {
50142 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50143 }
50144 {
50145 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50146 }
50147 {
50148 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50149 }
50150 {
50151 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50152 }
50153 {
50154 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50155 }
50156 {
50157 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50158 }
50159 {
50160 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50161 }
50162 {
50163 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50164 }
50165 {
50166 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50167 }
50168 {
50169 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50170 }
50171 {
50172 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50173 }
50174 {
50175 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50176 }
50177 {
50178 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50179 }
50180 {
50181 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50182 }
50183 {
50184 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50185 }
50186 {
50187 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50188 }
50189 {
50190 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50191 }
50192 {
50193 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50194 }
50195 {
50196 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50197 }
50198 {
50199 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50200 }
50201 {
50202 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50203 }
50204 {
50205 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50206 }
50207 {
50208 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50209 }
50210 {
50211 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50212 }
50213 {
50214 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50215 }
50216 {
50217 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50218 }
50219 {
50220 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50221 }
50222 {
50223 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50224 }
50225 {
50226 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50227 }
50228 {
50229 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50230 }
50231 {
50232 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50233 }
50234 {
50235 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50236 }
50237 {
50238 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50239 }
50240 {
50241 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50242 }
50243 {
50244 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50245 }
50246 {
50247 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50248 }
50249 {
50250 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50251 }
50252 {
50253 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50254 }
50255 {
50256 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50257 }
50258 {
50259 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50260 }
50261 {
50262 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50263 }
50264 {
50265 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50266 }
50267 {
50268 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50269 }
50270 {
50271 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50272 }
50273 {
50274 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50275 }
50276 {
50277 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50278 }
50279 {
50280 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50281 }
50282 {
50283 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50284 }
50285 {
50286 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50287 }
50288 {
50289 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50290 }
50291 {
50292 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50293 }
50294 {
50295 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50296 }
50297 {
50298 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50299 }
50300 {
50301 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50302 }
50303 {
50304 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50305 }
50306 {
50307 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50308 }
50309 {
50310 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50311 }
50312 {
50313 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50314 }
50315 {
50316 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50317 }
50318 {
50319 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50320 }
50321 {
50322 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50323 }
50324 {
50325 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50326 }
50327 {
50328 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50329 }
50330 {
50331 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50332 }
50333 {
50334 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50335 }
50336 {
50337 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50338 }
50339 {
50340 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50341 }
50342 {
50343 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50344 }
50345 {
50346 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50347 }
50348 {
50349 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50350 }
50351 {
50352 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50353 }
50354 {
50355 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50356 }
50357 {
50358 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50359 }
50360 {
50361 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50362 }
50363 {
50364 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50365 }
50366 {
50367 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50368 }
50369 {
50370 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50371 }
50372 {
50373 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50374 }
50375 {
50376 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50377 }
50378 {
50379 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50380 }
50381 {
50382 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50383 }
50384 {
50385 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50386 }
50387 {
50388 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50389 }
50390 {
50391 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50392 }
50393 {
50394 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50395 }
50396 {
50397 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50398 }
50399 {
50400 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50401 }
50402 {
50403 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50404 }
50405 {
50406 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50407 }
50408 {
50409 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50410 }
50411 {
50412 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50413 }
50414 {
50415 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50416 }
50417 {
50418 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50419 }
50420 {
50421 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50422 }
50423 {
50424 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50425 }
50426 {
50427 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50428 }
50429 {
50430 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50434 }
50435 {
50436 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50437 }
50438 {
50439 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50440 }
50441 {
50442 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50443 }
50444 {
50445 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50446 }
50447 {
50448 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50449 }
50450 {
50451 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50452 }
50453 {
50454 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50455 }
50456 {
50457 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50458 }
50459 {
50460 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50461 }
50462 {
50463 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50464 }
50465 {
50466 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50467 }
50468 {
50469 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50470 }
50471 {
50472 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50473 }
50474 {
50475 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50476 }
50477 {
50478 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50479 }
50480 {
50481 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50482 }
50483 {
50484 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50485 }
50486 {
50487 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50488 }
50489 {
50490 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50491 }
50492 {
50493 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50494 }
50495 {
50496 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50497 }
50498 {
50499 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50500 }
50501 {
50502 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50503 }
50504 {
50505 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50506 }
50507 {
50508 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50509 }
50510 {
50511 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50512 }
50513 {
50514 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50515 }
50516 {
50517 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50518 }
50519 {
50520 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50521 }
50522 {
50523 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50524 }
50525 {
50526 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50527 }
50528 {
50529 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50530 }
50531 {
50532 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50533 }
50534 {
50535 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50536 }
50537 {
50538 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50539 }
50540 {
50541 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50542 }
50543 {
50544 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50545 }
50546 {
50547 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50548 }
50549 {
50550 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50551 }
50552 {
50553 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50554 }
50555 {
50556 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50557 }
50558 {
50559 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50560 }
50561 {
50562 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50563 }
50564 {
50565 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50566 }
50567 {
50568 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50569 }
50570 {
50571 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50572 }
50573 {
50574 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50575 }
50576 {
50577 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50578 }
50579 {
50580 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50581 }
50582 {
50583 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50584 }
50585 {
50586 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50587 }
50588 {
50589 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50590 }
50591 {
50592 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50593 }
50594 {
50595 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50596 }
50597 {
50598 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50599 }
50600 {
50601 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50602 }
50603 {
50604 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50605 }
50606 {
50607 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50608 }
50609 {
50610 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50611 }
50612 {
50613 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50614 }
50615 {
50616 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50617 }
50618 {
50619 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50620 }
50621 {
50622 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50623 }
50624 {
50625 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50626 }
50627 {
50628 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50629 }
50630 {
50631 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50632 }
50633 {
50634 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50635 }
50636 {
50637 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50638 }
50639 {
50640 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50641 }
50642 {
50643 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50644 }
50645 {
50646 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50647 }
50648 {
50649 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50650 }
50651 {
50652 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50653 }
50654 {
50655 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50656 }
50657 {
50658 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50659 }
50660 {
50661 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50662 }
50663 {
50664 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50665 }
50666 {
50667 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50668 }
50669 {
50670 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50671 }
50672 {
50673 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50674 }
50675 {
50676 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50677 }
50678 {
50679 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50680 }
50681 {
50682 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50683 }
50684 {
50685 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50686 }
50687 {
50688 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50689 }
50690 {
50691 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50692 }
50693 {
50694 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50695 }
50696 {
50697 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50698 }
50699 {
50700 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50701 }
50702 {
50703 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50704 }
50705 {
50706 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50707 }
50708 {
50709 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50710 }
50711 {
50712 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50713 }
50714 {
50715 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50716 }
50717 {
50718 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50719 }
50720 {
50721 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50722 }
50723 {
50724 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50725 }
50726 {
50727 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50728 }
50729 {
50730 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50731 }
50732 {
50733 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50734 }
50735 {
50736 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50737 }
50738 {
50739 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50740 }
50741 {
50742 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50743 }
50744 {
50745 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50746 }
50747 {
50748 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50749 }
50750 {
50751 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50752 }
50753 {
50754 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50755 }
50756 {
50757 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50758 }
50759 {
50760 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50761 }
50762 {
50763 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50764 }
50765 {
50766 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50767 }
50768 {
50769 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50770 }
50771 {
50772 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50773 }
50774 {
50775 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50776 }
50777 {
50778 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50779 }
50780 {
50781 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50782 }
50783 {
50784 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50785 }
50786 {
50787 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50788 }
50789 {
50790 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50791 }
50792 {
50793 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50794 }
50795 {
50796 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50797 }
50798 {
50799 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50800 }
50801 {
50802 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50803 }
50804 {
50805 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50806 }
50807 {
50808 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50809 }
50810 {
50811 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50812 }
50813 {
50814 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50815 }
50816 {
50817 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50818 }
50819 {
50820 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50821 }
50822 {
50823 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50824 }
50825 {
50826 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
50827 }
50828 {
50829 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
50830 }
50831 {
50832 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
50833 }
50834 {
50835 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
50836 }
50837 {
50838 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
50839 }
50840 {
50841 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
50842 }
50843 {
50844 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
50845 }
50846 {
50847 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
50848 }
50849 {
50850 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
50851 }
50852 {
50853 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50854 }
50855 {
50856 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50857 }
50858 {
50859 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
50860 }
50861 {
50862 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
50863 }
50864 {
50865 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
50866 }
50867 {
50868 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
50869 }
50870 {
50871 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
50872 }
50873 {
50874 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
50875 }
50876 {
50877 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
50878 }
50879 {
50880 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
50881 }
50882 {
50883 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
50884 }
50885 {
50886 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
50887 }
50888 {
50889 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
50890 }
50891 {
50892 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
50893 }
50894 {
50895 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
50896 }
50897 {
50898 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
50899 }
50900 {
50901 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
50902 }
50903 {
50904 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
50905 }
50906 {
50907 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
50908 }
50909 {
50910 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
50911 }
50912 {
50913 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
50914 }
50915 {
50916 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
50917 }
50918 {
50919 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
50920 }
50921 {
50922 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
50923 }
50924 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50925 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50926 {
50927 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
50928 }
50929 {
50930 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
50931 }
50932 {
50933 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
50934 }
50935 {
50936 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
50937 }
50938 {
50939 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
50940 }
50941 {
50942 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
50943 }
50944 {
50945 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
50946 }
50947 {
50948 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
50949 }
50950 {
50951 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
50952 }
50953 {
50954 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
50955 }
50956 {
50957 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
50958 }
50959 {
50960 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
50961 }
50962 {
50963 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
50964 }
50965 {
50966 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
50967 }
50968 {
50969 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
50970 }
50971 {
50972 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
50973 }
50974 {
50975 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
50976 }
50977 {
50978 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
50979 }
50980 {
50981 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
50982 }
50983 {
50984 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
50985 }
50986 {
50987 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
50988 }
50989 {
50990 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
50991 }
50992 {
50993 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
50994 }
50995 {
50996 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
50997 }
50998 {
50999 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51000 }
51001 {
51002 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51003 }
51004 {
51005 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51006 }
51007 {
51008 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51009 }
51010 {
51011 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51012 }
51013 {
51014 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51015 }
51016 {
51017 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51018 }
51019 {
51020 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51021 }
51022 {
51023 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51024 }
51025 {
51026 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51027 }
51028 {
51029 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51030 }
51031 {
51032 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51033 }
51034 {
51035 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51036 }
51037 {
51038 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51039 }
51040 {
51041 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51042 }
51043 {
51044 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51045 }
51046 {
51047 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51048 }
51049 {
51050 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51051 }
51052 {
51053 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51054 }
51055 {
51056 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51057 }
51058 {
51059 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51060 }
51061 {
51062 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51063 }
51064 {
51065 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51066 }
51067 {
51068 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51069 }
51070 {
51071 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51072 }
51073 {
51074 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51075 }
51076 {
51077 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51078 }
51079 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51080 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51081 {
51082 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51083 }
51084 {
51085 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51086 }
51087 {
51088 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51089 }
51090
51091 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51092
51093
51094 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51095
51096 {
51097 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51098 }
51099 {
51100 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51101 }
51102 {
51103 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51104 }
51105 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51106 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51107 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51108 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51109 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51110 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51111 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51112 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51113 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51114 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51115 {
51116 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51117 }
51118 {
51119 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51120 }
51121 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51122 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51123 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51124 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51125 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51126 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51127 {
51128 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51129 }
51130 {
51131 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51132 }
51133 {
51134 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51135 }
51136 {
51137 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51138 }
51139 {
51140 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51141 }
51142 {
51143 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51144 }
51145 {
51146 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51147 }
51148 {
51149 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51150 }
51151 {
51152 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51153 }
51154 {
51155 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51156 }
51157 {
51158 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51159 }
51160 {
51161 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51162 }
51163 {
51164 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51165 }
51166 {
51167 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51168 }
51169 {
51170 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51171 }
51172 {
51173 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51174 }
51175 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51176 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51177 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51178 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51179 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51180 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51181 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51182 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51183 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51184 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51185 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51186 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51187 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51188 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51189 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51190 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51191 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51192 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51193 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51194 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51195 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51196 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51197 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51198 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51199 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51200 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51201 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51202 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51203 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51204 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51205 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51206 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51207 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51208 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51209 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51210 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51211 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51212 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51213 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51214 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51215 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51216 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51217 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51218 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51219 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51220 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51221 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51222 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51223 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51224 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51225 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51226 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51227 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51228 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51229 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51230 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51231 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51232 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51233 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51234 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51235 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51236 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51237 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51238 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51239 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51240 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51241 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51242 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51243 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51244 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51245 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51246 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51247 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51248 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51249 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51250 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51251 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51252 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51253 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51254 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51255 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51256 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51257 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51258 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51259 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51260 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51261 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51262 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51263 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51264 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51265 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51266 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51267 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51268 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51269 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51270 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51271 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51272 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51273 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51274 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51275 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51276 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51277 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51278 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51279 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51280 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51281 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51282 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51283 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51284 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51285 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51286 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51287 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51288 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51289 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51290 {
51291 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51292 }
51293 {
51294 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51295 }
51296 {
51297 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51298 }
51299 {
51300 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51301 }
51302 {
51303 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51304 }
51305 {
51306 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51307 }
51308 {
51309 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51310 }
51311 {
51312 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51313 }
51314 {
51315 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51316 }
51317 {
51318 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51319 }
51320 {
51321 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51322 }
51323 {
51324 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51325 }
51326 {
51327 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51328 }
51329 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51330 {
51331 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51332 }
51333 {
51334 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51335 }
51336 {
51337 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51338 }
51339 {
51340 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51341 }
51342 {
51343 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51344 }
51345 {
51346 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51347 }
51348 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51349 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51350 {
51351 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51352 }
51353 {
51354 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51355 }
51356 {
51357 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51358 }
51359 {
51360 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51361 }
51362 {
51363 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51364 }
51365 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51366 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51367 {
51368 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51369 }
51370 {
51371 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51372 }
51373 {
51374 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51375 }
51376 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51377 {
51378 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51379 }
51380 {
51381 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51382 }
51383 {
51384 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51385 }
51386 {
51387 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51388 }
51389 {
51390 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51391 }
51392 {
51393 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51394 }
51395 {
51396 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51397 }
51398 {
51399 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51400 }
51401 {
51402 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51403 }
51404 {
51405 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51406 }
51407 {
51408 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51409 }
51410 {
51411 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51412 }
51413 {
51414 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51415 }
51416 {
51417 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51418 }
51419 {
51420 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51421 }
51422 {
51423 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51424 }
51425 {
51426 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51427 }
51428 {
51429 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51430 }
51431 {
51432 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51433 }
51434
51435 // Initialize threading, some globals and such
51436 __wxPyPreStart(d);
51437
51438
51439 // Although these are defined in __version__ they need to be here too so
51440 // that an assert can be done to ensure that the wxPython and the wxWindows
51441 // versions match.
51442 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51443 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51444 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51445
51446 }
51447
wxWidgets (Impactor)