]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
subclass all updown controls in notebooks, not just the first one
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
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 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2616 PyObject* list = PyList_New(count);
2617
2618 if (!list) {
2619 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2620 wxPyEndBlockThreads(blocked);
2621 return NULL;
2622 }
2623
2624 for (int i=0; i<count; i++) {
2625 PyList_SetItem(list, i, wx2PyString(files[i]));
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return list;
2629 }
2630
2631
2632 static wxPyApp *new_wxPyApp(){
2633 wxPythonApp = new wxPyApp();
2634 return wxPythonApp;
2635 }
2636 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2637
2638 void wxApp_CleanUp() {
2639 __wxPyCleanup();
2640 }
2641
2642
2643 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2644
2645
2646 SWIGINTERNSHORT int
2647 SWIG_AsCharPtr(PyObject *obj, char **val)
2648 {
2649 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2650 return 1;
2651 }
2652 if (val) {
2653 PyErr_Clear();
2654 SWIG_type_error("char *", obj);
2655 }
2656 return 0;
2657 }
2658
2659
2660 SWIGINTERN PyObject *
2661 SWIG_FromCharPtr(const char* cptr)
2662 {
2663 if (cptr) {
2664 size_t size = strlen(cptr);
2665 if (size > INT_MAX) {
2666 return SWIG_NewPointerObj((char*)(cptr),
2667 SWIG_TypeQuery("char *"), 0);
2668 } else {
2669 if (size != 0) {
2670 return PyString_FromStringAndSize(cptr, size);
2671 } else {
2672 return PyString_FromString(cptr);
2673 }
2674 }
2675 }
2676 Py_INCREF(Py_None);
2677 return Py_None;
2678 }
2679
2680
2681 #ifdef __WXMAC__
2682
2683 // A dummy class that raises an exception if used...
2684 class wxEventLoop
2685 {
2686 public:
2687 wxEventLoop() { wxPyRaiseNotImplemented(); }
2688 int Run() { return 0; }
2689 void Exit(int rc = 0) {}
2690 bool Pending() const { return false; }
2691 bool Dispatch() { return false; }
2692 bool IsRunning() const { return false; }
2693 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2694 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2695 };
2696
2697 #else
2698
2699 #include <wx/evtloop.h>
2700
2701 #endif
2702
2703
2704
2705 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2706 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2707 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2708 static PyObject *wxWindow_GetChildren(wxWindow *self){
2709 wxWindowList& list = self->GetChildren();
2710 return wxPy_ConvertList(&list);
2711 }
2712 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2713 #if wxUSE_HOTKEY
2714 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2715 #else
2716 return false;
2717 #endif
2718 }
2719 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2720
2721
2722
2723 return false;
2724
2725 }
2726 static long wxWindow_GetHandle(wxWindow *self){
2727 return wxPyGetWinHandle(self);
2728 }
2729 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2730 self->AssociateHandle((WXWidget)handle);
2731 }
2732 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2733
2734 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowById(id, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByName( const wxString& name,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByName(name, parent);
2741 }
2742
2743 wxWindow* wxFindWindowByLabel( const wxString& label,
2744 const wxWindow *parent = NULL ) {
2745 return wxWindow::FindWindowByLabel(label, parent);
2746 }
2747
2748
2749 #ifdef __WXMSW__
2750 #include <wx/msw/private.h> // to get wxGetWindowId
2751 #endif
2752
2753
2754 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2755 #ifdef __WXMSW__
2756 WXHWND hWnd = (WXHWND)_hWnd;
2757 long id = wxGetWindowId(hWnd);
2758 wxWindow* win = new wxWindow;
2759 parent->AddChild(win);
2760 win->SetEventHandler(win);
2761 win->SetHWND(hWnd);
2762 win->SetId(id);
2763 win->SubclassWin(hWnd);
2764 win->AdoptAttributesFromHWND();
2765 win->SetupColours();
2766 return win;
2767 #else
2768 wxPyRaiseNotImplemented();
2769 return NULL;
2770 #endif
2771 }
2772
2773
2774 PyObject* GetTopLevelWindows() {
2775 return wxPy_ConvertList(&wxTopLevelWindows);
2776 }
2777
2778
2779 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2780 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2781 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2782
2783 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2784
2785 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2786 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2787 wxMenuItemList& list = self->GetMenuItems();
2788 return wxPy_ConvertList(&list);
2789 }
2790 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2791 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2792 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2793 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2794 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2795 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2796 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2797 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2798 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2799 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2800 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2801 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2802 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2803 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2804 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2805 static const wxString wxPyControlNameStr(wxControlNameStr);
2806 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2807 if (clientData) {
2808 wxPyClientData* data = new wxPyClientData(clientData);
2809 return self->Append(item, data);
2810 } else
2811 return self->Append(item);
2812 }
2813 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2814 if (clientData) {
2815 wxPyClientData* data = new wxPyClientData(clientData);
2816 return self->Insert(item, pos, data);
2817 } else
2818 return self->Insert(item, pos);
2819 }
2820 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2821 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2822 if (data) {
2823 Py_INCREF(data->m_obj);
2824 return data->m_obj;
2825 } else {
2826 Py_INCREF(Py_None);
2827 return Py_None;
2828 }
2829 }
2830 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2831 wxPyClientData* data = new wxPyClientData(clientData);
2832 self->SetClientObject(n, data);
2833 }
2834
2835
2836 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2837 wxPyUserData* data = NULL;
2838 if ( userData ) {
2839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2840 data = new wxPyUserData(userData);
2841 wxPyEndBlockThreads(blocked);
2842 }
2843 return new wxSizerItem(window, proportion, flag, border, data);
2844 }
2845 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2846 wxPyUserData* data = NULL;
2847 if ( userData ) {
2848 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2849 data = new wxPyUserData(userData);
2850 wxPyEndBlockThreads(blocked);
2851 }
2852 return new wxSizerItem(width, height, proportion, flag, border, data);
2853 }
2854 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2855 wxPyUserData* data = NULL;
2856 if ( userData ) {
2857 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2858 data = new wxPyUserData(userData);
2859 wxPyEndBlockThreads(blocked);
2860 }
2861 return new wxSizerItem(sizer, proportion, flag, border, data);
2862 }
2863
2864 #include <float.h>
2865 SWIGINTERN int
2866 SWIG_CheckDoubleInRange(double value, double min_value,
2867 double max_value, const char* errmsg)
2868 {
2869 if (value < min_value) {
2870 if (errmsg) {
2871 PyErr_Format(PyExc_OverflowError,
2872 "value %g is less than %s minimum %g",
2873 value, errmsg, min_value);
2874 }
2875 return 0;
2876 } else if (value > max_value) {
2877 if (errmsg) {
2878 PyErr_Format(PyExc_OverflowError,
2879 "value %g is greater than %s maximum %g",
2880 value, errmsg, max_value);
2881 }
2882 return 0;
2883 }
2884 return 1;
2885 }
2886
2887
2888 SWIGINTERN int
2889 SWIG_AsVal_float(PyObject *obj, float *val)
2890 {
2891 const char* errmsg = val ? "float" : (char*)0;
2892 double v;
2893 if (SWIG_AsVal_double(obj, &v)) {
2894 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2895 if (val) *val = (float)(v);
2896 return 1;
2897 } else {
2898 return 0;
2899 }
2900 } else {
2901 PyErr_Clear();
2902 }
2903 if (val) {
2904 SWIG_type_error(errmsg, obj);
2905 }
2906 return 0;
2907 }
2908
2909
2910 SWIGINTERNSHORT float
2911 SWIG_As_float(PyObject* obj)
2912 {
2913 float v;
2914 if (!SWIG_AsVal_float(obj, &v)) {
2915 /*
2916 this is needed to make valgrind/purify happier.
2917 */
2918 memset((void*)&v, 0, sizeof(float));
2919 }
2920 return v;
2921 }
2922
2923
2924 SWIGINTERNSHORT int
2925 SWIG_Check_float(PyObject* obj)
2926 {
2927 return SWIG_AsVal_float(obj, (float*)0);
2928 }
2929
2930
2931 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2932 #define SWIG_From_float PyFloat_FromDouble
2933 /*@@*/
2934
2935 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2936 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2937 if (data) {
2938 Py_INCREF(data->m_obj);
2939 return data->m_obj;
2940 } else {
2941 Py_INCREF(Py_None);
2942 return Py_None;
2943 }
2944 }
2945
2946 // Figure out the type of the sizer item
2947
2948 struct wxPySizerItemInfo {
2949 wxPySizerItemInfo()
2950 : window(NULL), sizer(NULL), gotSize(false),
2951 size(wxDefaultSize), gotPos(false), pos(-1)
2952 {}
2953
2954 wxWindow* window;
2955 wxSizer* sizer;
2956 bool gotSize;
2957 wxSize size;
2958 bool gotPos;
2959 int pos;
2960 };
2961
2962 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2963
2964 wxPySizerItemInfo info;
2965 wxSize size;
2966 wxSize* sizePtr = &size;
2967
2968 // Find out what the type of the item is
2969 // try wxWindow
2970 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2971 PyErr_Clear();
2972 info.window = NULL;
2973
2974 // try wxSizer
2975 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2976 PyErr_Clear();
2977 info.sizer = NULL;
2978
2979 // try wxSize or (w,h)
2980 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2981 info.size = *sizePtr;
2982 info.gotSize = true;
2983 }
2984
2985 // or a single int
2986 if (checkIdx && PyInt_Check(item)) {
2987 info.pos = PyInt_AsLong(item);
2988 info.gotPos = true;
2989 }
2990 }
2991 }
2992
2993 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2994 // no expected type, figure out what kind of error message to generate
2995 if ( !checkSize && !checkIdx )
2996 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2997 else if ( checkSize && !checkIdx )
2998 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2999 else if ( !checkSize && checkIdx)
3000 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
3001 else
3002 // can this one happen?
3003 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
3004 }
3005
3006 return info;
3007 }
3008
3009 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3010 if (!self->GetClientObject())
3011 self->SetClientObject(new wxPyOORClientData(_self));
3012 }
3013 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3014
3015 wxPyUserData* data = NULL;
3016 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3017 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3018 if ( userData && (info.window || info.sizer || info.gotSize) )
3019 data = new wxPyUserData(userData);
3020 wxPyEndBlockThreads(blocked);
3021
3022 // Now call the real Add method if a valid item type was found
3023 if ( info.window )
3024 return self->Add(info.window, proportion, flag, border, data);
3025 else if ( info.sizer )
3026 return self->Add(info.sizer, proportion, flag, border, data);
3027 else if (info.gotSize)
3028 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3029 proportion, flag, border, data);
3030 else
3031 return NULL;
3032 }
3033 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3034
3035 wxPyUserData* data = NULL;
3036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3037 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3038 if ( userData && (info.window || info.sizer || info.gotSize) )
3039 data = new wxPyUserData(userData);
3040 wxPyEndBlockThreads(blocked);
3041
3042 // Now call the real Insert method if a valid item type was found
3043 if ( info.window )
3044 return self->Insert(before, info.window, proportion, flag, border, data);
3045 else if ( info.sizer )
3046 return self->Insert(before, info.sizer, proportion, flag, border, data);
3047 else if (info.gotSize)
3048 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3049 proportion, flag, border, data);
3050 else
3051 return NULL;
3052 }
3053 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3054
3055 wxPyUserData* data = NULL;
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3058 if ( userData && (info.window || info.sizer || info.gotSize) )
3059 data = new wxPyUserData(userData);
3060 wxPyEndBlockThreads(blocked);
3061
3062 // Now call the real Prepend method if a valid item type was found
3063 if ( info.window )
3064 return self->Prepend(info.window, proportion, flag, border, data);
3065 else if ( info.sizer )
3066 return self->Prepend(info.sizer, proportion, flag, border, data);
3067 else if (info.gotSize)
3068 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3069 proportion, flag, border, data);
3070 else
3071 return NULL;
3072 }
3073 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->Remove(info.window);
3079 else if ( info.sizer )
3080 return self->Remove(info.sizer);
3081 else if ( info.gotPos )
3082 return self->Remove(info.pos);
3083 else
3084 return false;
3085 }
3086 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 return self->Detach(info.window);
3092 else if ( info.sizer )
3093 return self->Detach(info.sizer);
3094 else if ( info.gotPos )
3095 return self->Detach(info.pos);
3096 else
3097 return false;
3098 }
3099 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3102 wxPyEndBlockThreads(blocked);
3103 if ( info.window )
3104 return self->GetItem(info.window);
3105 else if ( info.sizer )
3106 return self->GetItem(info.sizer);
3107 else if ( info.gotPos )
3108 return self->GetItem(info.pos);
3109 else
3110 return NULL;
3111 }
3112 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3115 wxPyEndBlockThreads(blocked);
3116 if ( info.window )
3117 self->SetItemMinSize(info.window, size);
3118 else if ( info.sizer )
3119 self->SetItemMinSize(info.sizer, size);
3120 else if ( info.gotPos )
3121 self->SetItemMinSize(info.pos, size);
3122 }
3123 static PyObject *wxSizer_GetChildren(wxSizer *self){
3124 wxSizerItemList& list = self->GetChildren();
3125 return wxPy_ConvertList(&list);
3126 }
3127 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3130 wxPyEndBlockThreads(blocked);
3131 if ( info.window )
3132 return self->Show(info.window, show, recursive);
3133 else if ( info.sizer )
3134 return self->Show(info.sizer, show, recursive);
3135 else if ( info.gotPos )
3136 return self->Show(info.pos, show);
3137 else
3138 return false;
3139 }
3140 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3143 wxPyEndBlockThreads(blocked);
3144 if ( info.window )
3145 return self->IsShown(info.window);
3146 else if ( info.sizer )
3147 return self->IsShown(info.sizer);
3148 else if ( info.gotPos )
3149 return self->IsShown(info.pos);
3150 else
3151 return false;
3152 }
3153
3154 // See pyclasses.h
3155 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3156 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3157 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3158
3159
3160
3161
3162 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3163 {
3164 if (source == Py_None) {
3165 **obj = wxGBPosition(-1,-1);
3166 return true;
3167 }
3168 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3169 }
3170
3171 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3172 {
3173 if (source == Py_None) {
3174 **obj = wxGBSpan(-1,-1);
3175 return true;
3176 }
3177 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3178 }
3179
3180
3181 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3182 self->SetRow(row);
3183 self->SetCol(col);
3184 }
3185 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 PyObject* tup = PyTuple_New(2);
3188 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3189 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3190 wxPyEndBlockThreads(blocked);
3191 return tup;
3192 }
3193 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3194 self->SetRowspan(rowspan);
3195 self->SetColspan(colspan);
3196 }
3197 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 PyObject* tup = PyTuple_New(2);
3200 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3201 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3202 wxPyEndBlockThreads(blocked);
3203 return tup;
3204 }
3205 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3206 wxPyUserData* data = NULL;
3207 if ( userData ) {
3208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3209 data = new wxPyUserData(userData);
3210 wxPyEndBlockThreads(blocked);
3211 }
3212 return new wxGBSizerItem(window, pos, span, flag, border, data);
3213 }
3214 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3215 wxPyUserData* data = NULL;
3216 if ( userData ) {
3217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3218 data = new wxPyUserData(userData);
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3222 }
3223 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3224 wxPyUserData* data = NULL;
3225 if ( userData ) {
3226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3227 data = new wxPyUserData(userData);
3228 wxPyEndBlockThreads(blocked);
3229 }
3230 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3231 }
3232 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3233 int row, col;
3234 self->GetEndPos(row, col);
3235 return wxGBPosition(row, col);
3236 }
3237 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3238
3239 wxPyUserData* data = NULL;
3240 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3241 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3242 if ( userData && (info.window || info.sizer || info.gotSize) )
3243 data = new wxPyUserData(userData);
3244 wxPyEndBlockThreads(blocked);
3245
3246 // Now call the real Add method if a valid item type was found
3247 if ( info.window )
3248 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3249 else if ( info.sizer )
3250 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3251 else if (info.gotSize)
3252 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3253 pos, span, flag, border, data);
3254 return NULL;
3255 }
3256
3257
3258 #ifdef __cplusplus
3259 extern "C" {
3260 #endif
3261 static int _wrap_EmptyString_set(PyObject *) {
3262 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3263 return 1;
3264 }
3265
3266
3267 static PyObject *_wrap_EmptyString_get(void) {
3268 PyObject *pyobj;
3269
3270 {
3271 #if wxUSE_UNICODE
3272 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3273 #else
3274 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3275 #endif
3276 }
3277 return pyobj;
3278 }
3279
3280
3281 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3282 PyObject *resultobj;
3283 wxObject *arg1 = (wxObject *) 0 ;
3284 wxString result;
3285 PyObject * obj0 = 0 ;
3286 char *kwnames[] = {
3287 (char *) "self", NULL
3288 };
3289
3290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3292 if (SWIG_arg_fail(1)) SWIG_fail;
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 result = wxObject_GetClassName(arg1);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 {
3301 #if wxUSE_UNICODE
3302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3303 #else
3304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3305 #endif
3306 }
3307 return resultobj;
3308 fail:
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxObject *arg1 = (wxObject *) 0 ;
3316 PyObject * obj0 = 0 ;
3317 char *kwnames[] = {
3318 (char *) "self", NULL
3319 };
3320
3321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3323 if (SWIG_arg_fail(1)) SWIG_fail;
3324 {
3325 PyThreadState* __tstate = wxPyBeginAllowThreads();
3326 wxObject_Destroy(arg1);
3327
3328 wxPyEndAllowThreads(__tstate);
3329 if (PyErr_Occurred()) SWIG_fail;
3330 }
3331 Py_INCREF(Py_None); resultobj = Py_None;
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3339 PyObject *obj;
3340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3341 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3342 Py_INCREF(obj);
3343 return Py_BuildValue((char *)"");
3344 }
3345 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxSize *arg1 = (wxSize *) 0 ;
3348 int arg2 ;
3349 PyObject * obj0 = 0 ;
3350 PyObject * obj1 = 0 ;
3351 char *kwnames[] = {
3352 (char *) "self",(char *) "x", NULL
3353 };
3354
3355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3357 if (SWIG_arg_fail(1)) SWIG_fail;
3358 {
3359 arg2 = (int)(SWIG_As_int(obj1));
3360 if (SWIG_arg_fail(2)) SWIG_fail;
3361 }
3362 if (arg1) (arg1)->x = arg2;
3363
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxSize *arg1 = (wxSize *) 0 ;
3374 int result;
3375 PyObject * obj0 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 result = (int) ((arg1)->x);
3384
3385 {
3386 resultobj = SWIG_From_int((int)(result));
3387 }
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxSize *arg1 = (wxSize *) 0 ;
3397 int arg2 ;
3398 PyObject * obj0 = 0 ;
3399 PyObject * obj1 = 0 ;
3400 char *kwnames[] = {
3401 (char *) "self",(char *) "y", NULL
3402 };
3403
3404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3406 if (SWIG_arg_fail(1)) SWIG_fail;
3407 {
3408 arg2 = (int)(SWIG_As_int(obj1));
3409 if (SWIG_arg_fail(2)) SWIG_fail;
3410 }
3411 if (arg1) (arg1)->y = arg2;
3412
3413 Py_INCREF(Py_None); resultobj = Py_None;
3414 return resultobj;
3415 fail:
3416 return NULL;
3417 }
3418
3419
3420 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3421 PyObject *resultobj;
3422 wxSize *arg1 = (wxSize *) 0 ;
3423 int result;
3424 PyObject * obj0 = 0 ;
3425 char *kwnames[] = {
3426 (char *) "self", NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 result = (int) ((arg1)->y);
3433
3434 {
3435 resultobj = SWIG_From_int((int)(result));
3436 }
3437 return resultobj;
3438 fail:
3439 return NULL;
3440 }
3441
3442
3443 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3444 PyObject *resultobj;
3445 int arg1 = (int) 0 ;
3446 int arg2 = (int) 0 ;
3447 wxSize *result;
3448 PyObject * obj0 = 0 ;
3449 PyObject * obj1 = 0 ;
3450 char *kwnames[] = {
3451 (char *) "w",(char *) "h", NULL
3452 };
3453
3454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3455 if (obj0) {
3456 {
3457 arg1 = (int)(SWIG_As_int(obj0));
3458 if (SWIG_arg_fail(1)) SWIG_fail;
3459 }
3460 }
3461 if (obj1) {
3462 {
3463 arg2 = (int)(SWIG_As_int(obj1));
3464 if (SWIG_arg_fail(2)) SWIG_fail;
3465 }
3466 }
3467 {
3468 PyThreadState* __tstate = wxPyBeginAllowThreads();
3469 result = (wxSize *)new wxSize(arg1,arg2);
3470
3471 wxPyEndAllowThreads(__tstate);
3472 if (PyErr_Occurred()) SWIG_fail;
3473 }
3474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3475 return resultobj;
3476 fail:
3477 return NULL;
3478 }
3479
3480
3481 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3482 PyObject *resultobj;
3483 wxSize *arg1 = (wxSize *) 0 ;
3484 PyObject * obj0 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 {
3493 PyThreadState* __tstate = wxPyBeginAllowThreads();
3494 delete arg1;
3495
3496 wxPyEndAllowThreads(__tstate);
3497 if (PyErr_Occurred()) SWIG_fail;
3498 }
3499 Py_INCREF(Py_None); resultobj = Py_None;
3500 return resultobj;
3501 fail:
3502 return NULL;
3503 }
3504
3505
3506 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3507 PyObject *resultobj;
3508 wxSize *arg1 = (wxSize *) 0 ;
3509 wxSize *arg2 = 0 ;
3510 bool result;
3511 wxSize temp2 ;
3512 PyObject * obj0 = 0 ;
3513 PyObject * obj1 = 0 ;
3514 char *kwnames[] = {
3515 (char *) "self",(char *) "sz", NULL
3516 };
3517
3518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3520 if (SWIG_arg_fail(1)) SWIG_fail;
3521 {
3522 arg2 = &temp2;
3523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3524 }
3525 {
3526 PyThreadState* __tstate = wxPyBeginAllowThreads();
3527 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3528
3529 wxPyEndAllowThreads(__tstate);
3530 if (PyErr_Occurred()) SWIG_fail;
3531 }
3532 {
3533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3534 }
3535 return resultobj;
3536 fail:
3537 return NULL;
3538 }
3539
3540
3541 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3542 PyObject *resultobj;
3543 wxSize *arg1 = (wxSize *) 0 ;
3544 wxSize *arg2 = 0 ;
3545 bool result;
3546 wxSize temp2 ;
3547 PyObject * obj0 = 0 ;
3548 PyObject * obj1 = 0 ;
3549 char *kwnames[] = {
3550 (char *) "self",(char *) "sz", NULL
3551 };
3552
3553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3555 if (SWIG_arg_fail(1)) SWIG_fail;
3556 {
3557 arg2 = &temp2;
3558 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3559 }
3560 {
3561 PyThreadState* __tstate = wxPyBeginAllowThreads();
3562 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3563
3564 wxPyEndAllowThreads(__tstate);
3565 if (PyErr_Occurred()) SWIG_fail;
3566 }
3567 {
3568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3569 }
3570 return resultobj;
3571 fail:
3572 return NULL;
3573 }
3574
3575
3576 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3577 PyObject *resultobj;
3578 wxSize *arg1 = (wxSize *) 0 ;
3579 wxSize *arg2 = 0 ;
3580 wxSize result;
3581 wxSize temp2 ;
3582 PyObject * obj0 = 0 ;
3583 PyObject * obj1 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "self",(char *) "sz", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3590 if (SWIG_arg_fail(1)) SWIG_fail;
3591 {
3592 arg2 = &temp2;
3593 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 result = (arg1)->operator +((wxSize const &)*arg2);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 {
3603 wxSize * resultptr;
3604 resultptr = new wxSize((wxSize &)(result));
3605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3606 }
3607 return resultobj;
3608 fail:
3609 return NULL;
3610 }
3611
3612
3613 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3614 PyObject *resultobj;
3615 wxSize *arg1 = (wxSize *) 0 ;
3616 wxSize *arg2 = 0 ;
3617 wxSize result;
3618 wxSize temp2 ;
3619 PyObject * obj0 = 0 ;
3620 PyObject * obj1 = 0 ;
3621 char *kwnames[] = {
3622 (char *) "self",(char *) "sz", NULL
3623 };
3624
3625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3627 if (SWIG_arg_fail(1)) SWIG_fail;
3628 {
3629 arg2 = &temp2;
3630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3631 }
3632 {
3633 PyThreadState* __tstate = wxPyBeginAllowThreads();
3634 result = (arg1)->operator -((wxSize const &)*arg2);
3635
3636 wxPyEndAllowThreads(__tstate);
3637 if (PyErr_Occurred()) SWIG_fail;
3638 }
3639 {
3640 wxSize * resultptr;
3641 resultptr = new wxSize((wxSize &)(result));
3642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 wxSize *arg1 = (wxSize *) 0 ;
3653 wxSize *arg2 = 0 ;
3654 wxSize temp2 ;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "self",(char *) "sz", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3663 if (SWIG_arg_fail(1)) SWIG_fail;
3664 {
3665 arg2 = &temp2;
3666 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3667 }
3668 {
3669 PyThreadState* __tstate = wxPyBeginAllowThreads();
3670 (arg1)->IncTo((wxSize const &)*arg2);
3671
3672 wxPyEndAllowThreads(__tstate);
3673 if (PyErr_Occurred()) SWIG_fail;
3674 }
3675 Py_INCREF(Py_None); resultobj = Py_None;
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj;
3684 wxSize *arg1 = (wxSize *) 0 ;
3685 wxSize *arg2 = 0 ;
3686 wxSize temp2 ;
3687 PyObject * obj0 = 0 ;
3688 PyObject * obj1 = 0 ;
3689 char *kwnames[] = {
3690 (char *) "self",(char *) "sz", NULL
3691 };
3692
3693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3695 if (SWIG_arg_fail(1)) SWIG_fail;
3696 {
3697 arg2 = &temp2;
3698 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3699 }
3700 {
3701 PyThreadState* __tstate = wxPyBeginAllowThreads();
3702 (arg1)->DecTo((wxSize const &)*arg2);
3703
3704 wxPyEndAllowThreads(__tstate);
3705 if (PyErr_Occurred()) SWIG_fail;
3706 }
3707 Py_INCREF(Py_None); resultobj = Py_None;
3708 return resultobj;
3709 fail:
3710 return NULL;
3711 }
3712
3713
3714 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3715 PyObject *resultobj;
3716 wxSize *arg1 = (wxSize *) 0 ;
3717 int arg2 ;
3718 int arg3 ;
3719 PyObject * obj0 = 0 ;
3720 PyObject * obj1 = 0 ;
3721 PyObject * obj2 = 0 ;
3722 char *kwnames[] = {
3723 (char *) "self",(char *) "w",(char *) "h", NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 {
3730 arg2 = (int)(SWIG_As_int(obj1));
3731 if (SWIG_arg_fail(2)) SWIG_fail;
3732 }
3733 {
3734 arg3 = (int)(SWIG_As_int(obj2));
3735 if (SWIG_arg_fail(3)) SWIG_fail;
3736 }
3737 {
3738 PyThreadState* __tstate = wxPyBeginAllowThreads();
3739 (arg1)->Set(arg2,arg3);
3740
3741 wxPyEndAllowThreads(__tstate);
3742 if (PyErr_Occurred()) SWIG_fail;
3743 }
3744 Py_INCREF(Py_None); resultobj = Py_None;
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 wxSize *arg1 = (wxSize *) 0 ;
3754 int arg2 ;
3755 PyObject * obj0 = 0 ;
3756 PyObject * obj1 = 0 ;
3757 char *kwnames[] = {
3758 (char *) "self",(char *) "w", NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3763 if (SWIG_arg_fail(1)) SWIG_fail;
3764 {
3765 arg2 = (int)(SWIG_As_int(obj1));
3766 if (SWIG_arg_fail(2)) SWIG_fail;
3767 }
3768 {
3769 PyThreadState* __tstate = wxPyBeginAllowThreads();
3770 (arg1)->SetWidth(arg2);
3771
3772 wxPyEndAllowThreads(__tstate);
3773 if (PyErr_Occurred()) SWIG_fail;
3774 }
3775 Py_INCREF(Py_None); resultobj = Py_None;
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj;
3784 wxSize *arg1 = (wxSize *) 0 ;
3785 int arg2 ;
3786 PyObject * obj0 = 0 ;
3787 PyObject * obj1 = 0 ;
3788 char *kwnames[] = {
3789 (char *) "self",(char *) "h", NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3794 if (SWIG_arg_fail(1)) SWIG_fail;
3795 {
3796 arg2 = (int)(SWIG_As_int(obj1));
3797 if (SWIG_arg_fail(2)) SWIG_fail;
3798 }
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 (arg1)->SetHeight(arg2);
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 int result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (int)((wxSize const *)arg1)->GetWidth();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = SWIG_From_int((int)(result));
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 int result;
3845 PyObject * obj0 = 0 ;
3846 char *kwnames[] = {
3847 (char *) "self", NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 {
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 result = (int)((wxSize const *)arg1)->GetHeight();
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 {
3861 resultobj = SWIG_From_int((int)(result));
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 wxSize *arg1 = (wxSize *) 0 ;
3872 bool result;
3873 PyObject * obj0 = 0 ;
3874 char *kwnames[] = {
3875 (char *) "self", NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3880 if (SWIG_arg_fail(1)) SWIG_fail;
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3890 }
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj;
3899 wxSize *arg1 = (wxSize *) 0 ;
3900 wxSize *arg2 = 0 ;
3901 wxSize temp2 ;
3902 PyObject * obj0 = 0 ;
3903 PyObject * obj1 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self",(char *) "size", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3910 if (SWIG_arg_fail(1)) SWIG_fail;
3911 {
3912 arg2 = &temp2;
3913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3914 }
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 (arg1)->SetDefaults((wxSize const &)*arg2);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 Py_INCREF(Py_None); resultobj = Py_None;
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3930 PyObject *resultobj;
3931 wxSize *arg1 = (wxSize *) 0 ;
3932 PyObject *result;
3933 PyObject * obj0 = 0 ;
3934 char *kwnames[] = {
3935 (char *) "self", NULL
3936 };
3937
3938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3940 if (SWIG_arg_fail(1)) SWIG_fail;
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (PyObject *)wxSize_Get(arg1);
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 resultobj = result;
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3956 PyObject *obj;
3957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3958 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3959 Py_INCREF(obj);
3960 return Py_BuildValue((char *)"");
3961 }
3962 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3965 double arg2 ;
3966 PyObject * obj0 = 0 ;
3967 PyObject * obj1 = 0 ;
3968 char *kwnames[] = {
3969 (char *) "self",(char *) "x", NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 {
3976 arg2 = (double)(SWIG_As_double(obj1));
3977 if (SWIG_arg_fail(2)) SWIG_fail;
3978 }
3979 if (arg1) (arg1)->x = arg2;
3980
3981 Py_INCREF(Py_None); resultobj = Py_None;
3982 return resultobj;
3983 fail:
3984 return NULL;
3985 }
3986
3987
3988 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3989 PyObject *resultobj;
3990 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3991 double result;
3992 PyObject * obj0 = 0 ;
3993 char *kwnames[] = {
3994 (char *) "self", NULL
3995 };
3996
3997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3999 if (SWIG_arg_fail(1)) SWIG_fail;
4000 result = (double) ((arg1)->x);
4001
4002 {
4003 resultobj = SWIG_From_double((double)(result));
4004 }
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj;
4013 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4014 double arg2 ;
4015 PyObject * obj0 = 0 ;
4016 PyObject * obj1 = 0 ;
4017 char *kwnames[] = {
4018 (char *) "self",(char *) "y", NULL
4019 };
4020
4021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 {
4025 arg2 = (double)(SWIG_As_double(obj1));
4026 if (SWIG_arg_fail(2)) SWIG_fail;
4027 }
4028 if (arg1) (arg1)->y = arg2;
4029
4030 Py_INCREF(Py_None); resultobj = Py_None;
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj;
4039 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4040 double result;
4041 PyObject * obj0 = 0 ;
4042 char *kwnames[] = {
4043 (char *) "self", NULL
4044 };
4045
4046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4048 if (SWIG_arg_fail(1)) SWIG_fail;
4049 result = (double) ((arg1)->y);
4050
4051 {
4052 resultobj = SWIG_From_double((double)(result));
4053 }
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj;
4062 double arg1 = (double) 0.0 ;
4063 double arg2 = (double) 0.0 ;
4064 wxRealPoint *result;
4065 PyObject * obj0 = 0 ;
4066 PyObject * obj1 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "x",(char *) "y", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4072 if (obj0) {
4073 {
4074 arg1 = (double)(SWIG_As_double(obj0));
4075 if (SWIG_arg_fail(1)) SWIG_fail;
4076 }
4077 }
4078 if (obj1) {
4079 {
4080 arg2 = (double)(SWIG_As_double(obj1));
4081 if (SWIG_arg_fail(2)) SWIG_fail;
4082 }
4083 }
4084 {
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4087
4088 wxPyEndAllowThreads(__tstate);
4089 if (PyErr_Occurred()) SWIG_fail;
4090 }
4091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4092 return resultobj;
4093 fail:
4094 return NULL;
4095 }
4096
4097
4098 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4099 PyObject *resultobj;
4100 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4101 PyObject * obj0 = 0 ;
4102 char *kwnames[] = {
4103 (char *) "self", NULL
4104 };
4105
4106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4108 if (SWIG_arg_fail(1)) SWIG_fail;
4109 {
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 delete arg1;
4112
4113 wxPyEndAllowThreads(__tstate);
4114 if (PyErr_Occurred()) SWIG_fail;
4115 }
4116 Py_INCREF(Py_None); resultobj = Py_None;
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
4123 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj;
4125 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4126 wxRealPoint *arg2 = 0 ;
4127 bool result;
4128 wxRealPoint temp2 ;
4129 PyObject * obj0 = 0 ;
4130 PyObject * obj1 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "self",(char *) "pt", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 {
4139 arg2 = &temp2;
4140 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4141 }
4142 {
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4145
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 {
4150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4151 }
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4161 wxRealPoint *arg2 = 0 ;
4162 bool result;
4163 wxRealPoint temp2 ;
4164 PyObject * obj0 = 0 ;
4165 PyObject * obj1 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "self",(char *) "pt", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4172 if (SWIG_arg_fail(1)) SWIG_fail;
4173 {
4174 arg2 = &temp2;
4175 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4176 }
4177 {
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4180
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 {
4185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4186 }
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4194 PyObject *resultobj;
4195 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4196 wxRealPoint *arg2 = 0 ;
4197 wxRealPoint result;
4198 wxRealPoint temp2 ;
4199 PyObject * obj0 = 0 ;
4200 PyObject * obj1 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "self",(char *) "pt", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4207 if (SWIG_arg_fail(1)) SWIG_fail;
4208 {
4209 arg2 = &temp2;
4210 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4211 }
4212 {
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4215
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 wxRealPoint * resultptr;
4221 resultptr = new wxRealPoint((wxRealPoint &)(result));
4222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4223 }
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4231 PyObject *resultobj;
4232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4233 wxRealPoint *arg2 = 0 ;
4234 wxRealPoint result;
4235 wxRealPoint temp2 ;
4236 PyObject * obj0 = 0 ;
4237 PyObject * obj1 = 0 ;
4238 char *kwnames[] = {
4239 (char *) "self",(char *) "pt", NULL
4240 };
4241
4242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4244 if (SWIG_arg_fail(1)) SWIG_fail;
4245 {
4246 arg2 = &temp2;
4247 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4248 }
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4252
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 {
4257 wxRealPoint * resultptr;
4258 resultptr = new wxRealPoint((wxRealPoint &)(result));
4259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4260 }
4261 return resultobj;
4262 fail:
4263 return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4268 PyObject *resultobj;
4269 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4270 double arg2 ;
4271 double arg3 ;
4272 PyObject * obj0 = 0 ;
4273 PyObject * obj1 = 0 ;
4274 PyObject * obj2 = 0 ;
4275 char *kwnames[] = {
4276 (char *) "self",(char *) "x",(char *) "y", NULL
4277 };
4278
4279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4281 if (SWIG_arg_fail(1)) SWIG_fail;
4282 {
4283 arg2 = (double)(SWIG_As_double(obj1));
4284 if (SWIG_arg_fail(2)) SWIG_fail;
4285 }
4286 {
4287 arg3 = (double)(SWIG_As_double(obj2));
4288 if (SWIG_arg_fail(3)) SWIG_fail;
4289 }
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 wxRealPoint_Set(arg1,arg2,arg3);
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 Py_INCREF(Py_None); resultobj = Py_None;
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj;
4306 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4307 PyObject *result;
4308 PyObject * obj0 = 0 ;
4309 char *kwnames[] = {
4310 (char *) "self", NULL
4311 };
4312
4313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4315 if (SWIG_arg_fail(1)) SWIG_fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = (PyObject *)wxRealPoint_Get(arg1);
4319
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = result;
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4331 PyObject *obj;
4332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4333 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4334 Py_INCREF(obj);
4335 return Py_BuildValue((char *)"");
4336 }
4337 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPoint *arg1 = (wxPoint *) 0 ;
4340 int arg2 ;
4341 PyObject * obj0 = 0 ;
4342 PyObject * obj1 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self",(char *) "x", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 arg2 = (int)(SWIG_As_int(obj1));
4352 if (SWIG_arg_fail(2)) SWIG_fail;
4353 }
4354 if (arg1) (arg1)->x = arg2;
4355
4356 Py_INCREF(Py_None); resultobj = Py_None;
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 wxPoint *arg1 = (wxPoint *) 0 ;
4366 int result;
4367 PyObject * obj0 = 0 ;
4368 char *kwnames[] = {
4369 (char *) "self", NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4374 if (SWIG_arg_fail(1)) SWIG_fail;
4375 result = (int) ((arg1)->x);
4376
4377 {
4378 resultobj = SWIG_From_int((int)(result));
4379 }
4380 return resultobj;
4381 fail:
4382 return NULL;
4383 }
4384
4385
4386 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4387 PyObject *resultobj;
4388 wxPoint *arg1 = (wxPoint *) 0 ;
4389 int arg2 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 char *kwnames[] = {
4393 (char *) "self",(char *) "y", NULL
4394 };
4395
4396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4398 if (SWIG_arg_fail(1)) SWIG_fail;
4399 {
4400 arg2 = (int)(SWIG_As_int(obj1));
4401 if (SWIG_arg_fail(2)) SWIG_fail;
4402 }
4403 if (arg1) (arg1)->y = arg2;
4404
4405 Py_INCREF(Py_None); resultobj = Py_None;
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 wxPoint *arg1 = (wxPoint *) 0 ;
4415 int result;
4416 PyObject * obj0 = 0 ;
4417 char *kwnames[] = {
4418 (char *) "self", NULL
4419 };
4420
4421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4423 if (SWIG_arg_fail(1)) SWIG_fail;
4424 result = (int) ((arg1)->y);
4425
4426 {
4427 resultobj = SWIG_From_int((int)(result));
4428 }
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj;
4437 int arg1 = (int) 0 ;
4438 int arg2 = (int) 0 ;
4439 wxPoint *result;
4440 PyObject * obj0 = 0 ;
4441 PyObject * obj1 = 0 ;
4442 char *kwnames[] = {
4443 (char *) "x",(char *) "y", NULL
4444 };
4445
4446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4447 if (obj0) {
4448 {
4449 arg1 = (int)(SWIG_As_int(obj0));
4450 if (SWIG_arg_fail(1)) SWIG_fail;
4451 }
4452 }
4453 if (obj1) {
4454 {
4455 arg2 = (int)(SWIG_As_int(obj1));
4456 if (SWIG_arg_fail(2)) SWIG_fail;
4457 }
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (wxPoint *)new wxPoint(arg1,arg2);
4462
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4474 PyObject *resultobj;
4475 wxPoint *arg1 = (wxPoint *) 0 ;
4476 PyObject * obj0 = 0 ;
4477 char *kwnames[] = {
4478 (char *) "self", NULL
4479 };
4480
4481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4483 if (SWIG_arg_fail(1)) SWIG_fail;
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 delete arg1;
4487
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 Py_INCREF(Py_None); resultobj = Py_None;
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj;
4500 wxPoint *arg1 = (wxPoint *) 0 ;
4501 wxPoint *arg2 = 0 ;
4502 bool result;
4503 wxPoint temp2 ;
4504 PyObject * obj0 = 0 ;
4505 PyObject * obj1 = 0 ;
4506 char *kwnames[] = {
4507 (char *) "self",(char *) "pt", NULL
4508 };
4509
4510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4512 if (SWIG_arg_fail(1)) SWIG_fail;
4513 {
4514 arg2 = &temp2;
4515 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4516 }
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4520
4521 wxPyEndAllowThreads(__tstate);
4522 if (PyErr_Occurred()) SWIG_fail;
4523 }
4524 {
4525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4526 }
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj;
4535 wxPoint *arg1 = (wxPoint *) 0 ;
4536 wxPoint *arg2 = 0 ;
4537 bool result;
4538 wxPoint temp2 ;
4539 PyObject * obj0 = 0 ;
4540 PyObject * obj1 = 0 ;
4541 char *kwnames[] = {
4542 (char *) "self",(char *) "pt", NULL
4543 };
4544
4545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(1)) SWIG_fail;
4548 {
4549 arg2 = &temp2;
4550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4551 }
4552 {
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4555
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4561 }
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj;
4570 wxPoint *arg1 = (wxPoint *) 0 ;
4571 wxPoint *arg2 = 0 ;
4572 wxPoint result;
4573 wxPoint temp2 ;
4574 PyObject * obj0 = 0 ;
4575 PyObject * obj1 = 0 ;
4576 char *kwnames[] = {
4577 (char *) "self",(char *) "pt", NULL
4578 };
4579
4580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4582 if (SWIG_arg_fail(1)) SWIG_fail;
4583 {
4584 arg2 = &temp2;
4585 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4586 }
4587 {
4588 PyThreadState* __tstate = wxPyBeginAllowThreads();
4589 result = (arg1)->operator +((wxPoint const &)*arg2);
4590
4591 wxPyEndAllowThreads(__tstate);
4592 if (PyErr_Occurred()) SWIG_fail;
4593 }
4594 {
4595 wxPoint * resultptr;
4596 resultptr = new wxPoint((wxPoint &)(result));
4597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4598 }
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
4605 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4606 PyObject *resultobj;
4607 wxPoint *arg1 = (wxPoint *) 0 ;
4608 wxPoint *arg2 = 0 ;
4609 wxPoint result;
4610 wxPoint temp2 ;
4611 PyObject * obj0 = 0 ;
4612 PyObject * obj1 = 0 ;
4613 char *kwnames[] = {
4614 (char *) "self",(char *) "pt", NULL
4615 };
4616
4617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4619 if (SWIG_arg_fail(1)) SWIG_fail;
4620 {
4621 arg2 = &temp2;
4622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4623 }
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 result = (arg1)->operator -((wxPoint const &)*arg2);
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 {
4632 wxPoint * resultptr;
4633 resultptr = new wxPoint((wxPoint &)(result));
4634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4635 }
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj;
4644 wxPoint *arg1 = (wxPoint *) 0 ;
4645 wxPoint *arg2 = 0 ;
4646 wxPoint *result;
4647 wxPoint temp2 ;
4648 PyObject * obj0 = 0 ;
4649 PyObject * obj1 = 0 ;
4650 char *kwnames[] = {
4651 (char *) "self",(char *) "pt", NULL
4652 };
4653
4654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4656 if (SWIG_arg_fail(1)) SWIG_fail;
4657 {
4658 arg2 = &temp2;
4659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4660 }
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 {
4664 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4665 result = (wxPoint *) &_result_ref;
4666 }
4667
4668 wxPyEndAllowThreads(__tstate);
4669 if (PyErr_Occurred()) SWIG_fail;
4670 }
4671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4672 return resultobj;
4673 fail:
4674 return NULL;
4675 }
4676
4677
4678 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4679 PyObject *resultobj;
4680 wxPoint *arg1 = (wxPoint *) 0 ;
4681 wxPoint *arg2 = 0 ;
4682 wxPoint *result;
4683 wxPoint temp2 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char *kwnames[] = {
4687 (char *) "self",(char *) "pt", NULL
4688 };
4689
4690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4692 if (SWIG_arg_fail(1)) SWIG_fail;
4693 {
4694 arg2 = &temp2;
4695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4696 }
4697 {
4698 PyThreadState* __tstate = wxPyBeginAllowThreads();
4699 {
4700 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4701 result = (wxPoint *) &_result_ref;
4702 }
4703
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj;
4716 wxPoint *arg1 = (wxPoint *) 0 ;
4717 long arg2 ;
4718 long arg3 ;
4719 PyObject * obj0 = 0 ;
4720 PyObject * obj1 = 0 ;
4721 PyObject * obj2 = 0 ;
4722 char *kwnames[] = {
4723 (char *) "self",(char *) "x",(char *) "y", NULL
4724 };
4725
4726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4728 if (SWIG_arg_fail(1)) SWIG_fail;
4729 {
4730 arg2 = (long)(SWIG_As_long(obj1));
4731 if (SWIG_arg_fail(2)) SWIG_fail;
4732 }
4733 {
4734 arg3 = (long)(SWIG_As_long(obj2));
4735 if (SWIG_arg_fail(3)) SWIG_fail;
4736 }
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 wxPoint_Set(arg1,arg2,arg3);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 Py_INCREF(Py_None); resultobj = Py_None;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj;
4753 wxPoint *arg1 = (wxPoint *) 0 ;
4754 PyObject *result;
4755 PyObject * obj0 = 0 ;
4756 char *kwnames[] = {
4757 (char *) "self", NULL
4758 };
4759
4760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4762 if (SWIG_arg_fail(1)) SWIG_fail;
4763 {
4764 PyThreadState* __tstate = wxPyBeginAllowThreads();
4765 result = (PyObject *)wxPoint_Get(arg1);
4766
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = result;
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4778 PyObject *obj;
4779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4780 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4781 Py_INCREF(obj);
4782 return Py_BuildValue((char *)"");
4783 }
4784 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 int arg1 = (int) 0 ;
4787 int arg2 = (int) 0 ;
4788 int arg3 = (int) 0 ;
4789 int arg4 = (int) 0 ;
4790 wxRect *result;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 PyObject * obj2 = 0 ;
4794 PyObject * obj3 = 0 ;
4795 char *kwnames[] = {
4796 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4797 };
4798
4799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4800 if (obj0) {
4801 {
4802 arg1 = (int)(SWIG_As_int(obj0));
4803 if (SWIG_arg_fail(1)) SWIG_fail;
4804 }
4805 }
4806 if (obj1) {
4807 {
4808 arg2 = (int)(SWIG_As_int(obj1));
4809 if (SWIG_arg_fail(2)) SWIG_fail;
4810 }
4811 }
4812 if (obj2) {
4813 {
4814 arg3 = (int)(SWIG_As_int(obj2));
4815 if (SWIG_arg_fail(3)) SWIG_fail;
4816 }
4817 }
4818 if (obj3) {
4819 {
4820 arg4 = (int)(SWIG_As_int(obj3));
4821 if (SWIG_arg_fail(4)) SWIG_fail;
4822 }
4823 }
4824 {
4825 PyThreadState* __tstate = wxPyBeginAllowThreads();
4826 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4827
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj;
4840 wxPoint *arg1 = 0 ;
4841 wxPoint *arg2 = 0 ;
4842 wxRect *result;
4843 wxPoint temp1 ;
4844 wxPoint temp2 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 char *kwnames[] = {
4848 (char *) "topLeft",(char *) "bottomRight", NULL
4849 };
4850
4851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4852 {
4853 arg1 = &temp1;
4854 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4855 }
4856 {
4857 arg2 = &temp2;
4858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4859 }
4860 {
4861 PyThreadState* __tstate = wxPyBeginAllowThreads();
4862 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4863
4864 wxPyEndAllowThreads(__tstate);
4865 if (PyErr_Occurred()) SWIG_fail;
4866 }
4867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4868 return resultobj;
4869 fail:
4870 return NULL;
4871 }
4872
4873
4874 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4875 PyObject *resultobj;
4876 wxPoint *arg1 = 0 ;
4877 wxSize *arg2 = 0 ;
4878 wxRect *result;
4879 wxPoint temp1 ;
4880 wxSize temp2 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 char *kwnames[] = {
4884 (char *) "pos",(char *) "size", NULL
4885 };
4886
4887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4888 {
4889 arg1 = &temp1;
4890 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4891 }
4892 {
4893 arg2 = &temp2;
4894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4895 }
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxSize *arg1 = 0 ;
4913 wxRect *result;
4914 wxSize temp1 ;
4915 PyObject * obj0 = 0 ;
4916 char *kwnames[] = {
4917 (char *) "size", NULL
4918 };
4919
4920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4921 {
4922 arg1 = &temp1;
4923 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4924 }
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4928
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj;
4941 wxRect *arg1 = (wxRect *) 0 ;
4942 PyObject * obj0 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "self", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 delete arg1;
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 Py_INCREF(Py_None); resultobj = Py_None;
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj;
4966 wxRect *arg1 = (wxRect *) 0 ;
4967 int result;
4968 PyObject * obj0 = 0 ;
4969 char *kwnames[] = {
4970 (char *) "self", NULL
4971 };
4972
4973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4975 if (SWIG_arg_fail(1)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (int)((wxRect const *)arg1)->GetX();
4979
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 {
4984 resultobj = SWIG_From_int((int)(result));
4985 }
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj;
4994 wxRect *arg1 = (wxRect *) 0 ;
4995 int arg2 ;
4996 PyObject * obj0 = 0 ;
4997 PyObject * obj1 = 0 ;
4998 char *kwnames[] = {
4999 (char *) "self",(char *) "x", NULL
5000 };
5001
5002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5004 if (SWIG_arg_fail(1)) SWIG_fail;
5005 {
5006 arg2 = (int)(SWIG_As_int(obj1));
5007 if (SWIG_arg_fail(2)) SWIG_fail;
5008 }
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 (arg1)->SetX(arg2);
5012
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 Py_INCREF(Py_None); resultobj = Py_None;
5017 return resultobj;
5018 fail:
5019 return NULL;
5020 }
5021
5022
5023 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5024 PyObject *resultobj;
5025 wxRect *arg1 = (wxRect *) 0 ;
5026 int result;
5027 PyObject * obj0 = 0 ;
5028 char *kwnames[] = {
5029 (char *) "self", NULL
5030 };
5031
5032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5034 if (SWIG_arg_fail(1)) SWIG_fail;
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (int)(arg1)->GetY();
5038
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 {
5043 resultobj = SWIG_From_int((int)(result));
5044 }
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxRect *arg1 = (wxRect *) 0 ;
5054 int arg2 ;
5055 PyObject * obj0 = 0 ;
5056 PyObject * obj1 = 0 ;
5057 char *kwnames[] = {
5058 (char *) "self",(char *) "y", NULL
5059 };
5060
5061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5063 if (SWIG_arg_fail(1)) SWIG_fail;
5064 {
5065 arg2 = (int)(SWIG_As_int(obj1));
5066 if (SWIG_arg_fail(2)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->SetY(arg2);
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_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj;
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_GetWidth",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)->GetWidth();
5097
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = SWIG_From_int((int)(result));
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj;
5112 wxRect *arg1 = (wxRect *) 0 ;
5113 int arg2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "self",(char *) "w", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",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 = (int)(SWIG_As_int(obj1));
5125 if (SWIG_arg_fail(2)) SWIG_fail;
5126 }
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 (arg1)->SetWidth(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_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj;
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_GetHeight",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)((wxRect const *)arg1)->GetHeight();
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = SWIG_From_int((int)(result));
5162 }
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj;
5171 wxRect *arg1 = (wxRect *) 0 ;
5172 int arg2 ;
5173 PyObject * obj0 = 0 ;
5174 PyObject * obj1 = 0 ;
5175 char *kwnames[] = {
5176 (char *) "self",(char *) "h", NULL
5177 };
5178
5179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",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 = (int)(SWIG_As_int(obj1));
5184 if (SWIG_arg_fail(2)) SWIG_fail;
5185 }
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 (arg1)->SetHeight(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_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj;
5202 wxRect *arg1 = (wxRect *) 0 ;
5203 wxPoint result;
5204 PyObject * obj0 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "self", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",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 = ((wxRect const *)arg1)->GetPosition();
5215
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 {
5220 wxPoint * resultptr;
5221 resultptr = new wxPoint((wxPoint &)(result));
5222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5223 }
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj;
5232 wxRect *arg1 = (wxRect *) 0 ;
5233 wxPoint *arg2 = 0 ;
5234 wxPoint temp2 ;
5235 PyObject * obj0 = 0 ;
5236 PyObject * obj1 = 0 ;
5237 char *kwnames[] = {
5238 (char *) "self",(char *) "p", NULL
5239 };
5240
5241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5243 if (SWIG_arg_fail(1)) SWIG_fail;
5244 {
5245 arg2 = &temp2;
5246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5247 }
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 (arg1)->SetPosition((wxPoint const &)*arg2);
5251
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 Py_INCREF(Py_None); resultobj = Py_None;
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj;
5264 wxRect *arg1 = (wxRect *) 0 ;
5265 wxSize result;
5266 PyObject * obj0 = 0 ;
5267 char *kwnames[] = {
5268 (char *) "self", NULL
5269 };
5270
5271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5273 if (SWIG_arg_fail(1)) SWIG_fail;
5274 {
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = ((wxRect const *)arg1)->GetSize();
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 wxSize * resultptr;
5283 resultptr = new wxSize((wxSize &)(result));
5284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5285 }
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj;
5294 wxRect *arg1 = (wxRect *) 0 ;
5295 wxSize *arg2 = 0 ;
5296 wxSize temp2 ;
5297 PyObject * obj0 = 0 ;
5298 PyObject * obj1 = 0 ;
5299 char *kwnames[] = {
5300 (char *) "self",(char *) "s", NULL
5301 };
5302
5303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5305 if (SWIG_arg_fail(1)) SWIG_fail;
5306 {
5307 arg2 = &temp2;
5308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5309 }
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 (arg1)->SetSize((wxSize const &)*arg2);
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 Py_INCREF(Py_None); resultobj = Py_None;
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj;
5326 wxRect *arg1 = (wxRect *) 0 ;
5327 bool result;
5328 PyObject * obj0 = 0 ;
5329 char *kwnames[] = {
5330 (char *) "self", NULL
5331 };
5332
5333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5335 if (SWIG_arg_fail(1)) SWIG_fail;
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (bool)((wxRect const *)arg1)->IsEmpty();
5339
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5345 }
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj;
5354 wxRect *arg1 = (wxRect *) 0 ;
5355 wxPoint result;
5356 PyObject * obj0 = 0 ;
5357 char *kwnames[] = {
5358 (char *) "self", NULL
5359 };
5360
5361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5363 if (SWIG_arg_fail(1)) SWIG_fail;
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = ((wxRect const *)arg1)->GetTopLeft();
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 wxPoint * resultptr;
5373 resultptr = new wxPoint((wxPoint &)(result));
5374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5375 }
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5383 PyObject *resultobj;
5384 wxRect *arg1 = (wxRect *) 0 ;
5385 wxPoint *arg2 = 0 ;
5386 wxPoint temp2 ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 char *kwnames[] = {
5390 (char *) "self",(char *) "p", NULL
5391 };
5392
5393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5395 if (SWIG_arg_fail(1)) SWIG_fail;
5396 {
5397 arg2 = &temp2;
5398 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5399 }
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5403
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 Py_INCREF(Py_None); resultobj = Py_None;
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj;
5416 wxRect *arg1 = (wxRect *) 0 ;
5417 wxPoint result;
5418 PyObject * obj0 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(1)) SWIG_fail;
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = ((wxRect const *)arg1)->GetBottomRight();
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 wxPoint * resultptr;
5435 resultptr = new wxPoint((wxPoint &)(result));
5436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj;
5446 wxRect *arg1 = (wxRect *) 0 ;
5447 wxPoint *arg2 = 0 ;
5448 wxPoint temp2 ;
5449 PyObject * obj0 = 0 ;
5450 PyObject * obj1 = 0 ;
5451 char *kwnames[] = {
5452 (char *) "self",(char *) "p", NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5457 if (SWIG_arg_fail(1)) SWIG_fail;
5458 {
5459 arg2 = &temp2;
5460 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5461 }
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 Py_INCREF(Py_None); resultobj = Py_None;
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj;
5478 wxRect *arg1 = (wxRect *) 0 ;
5479 int result;
5480 PyObject * obj0 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5487 if (SWIG_arg_fail(1)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (int)((wxRect const *)arg1)->GetLeft();
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = SWIG_From_int((int)(result));
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int result;
5508 PyObject * obj0 = 0 ;
5509 char *kwnames[] = {
5510 (char *) "self", NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5515 if (SWIG_arg_fail(1)) SWIG_fail;
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 result = (int)((wxRect const *)arg1)->GetTop();
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 resultobj = SWIG_From_int((int)(result));
5525 }
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5533 PyObject *resultobj;
5534 wxRect *arg1 = (wxRect *) 0 ;
5535 int result;
5536 PyObject * obj0 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",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 = (int)((wxRect const *)arg1)->GetBottom();
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 resultobj = SWIG_From_int((int)(result));
5553 }
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj;
5562 wxRect *arg1 = (wxRect *) 0 ;
5563 int result;
5564 PyObject * obj0 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (int)((wxRect const *)arg1)->GetRight();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = SWIG_From_int((int)(result));
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 wxRect *arg1 = (wxRect *) 0 ;
5591 int arg2 ;
5592 PyObject * obj0 = 0 ;
5593 PyObject * obj1 = 0 ;
5594 char *kwnames[] = {
5595 (char *) "self",(char *) "left", NULL
5596 };
5597
5598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5600 if (SWIG_arg_fail(1)) SWIG_fail;
5601 {
5602 arg2 = (int)(SWIG_As_int(obj1));
5603 if (SWIG_arg_fail(2)) SWIG_fail;
5604 }
5605 {
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 (arg1)->SetLeft(arg2);
5608
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 Py_INCREF(Py_None); resultobj = Py_None;
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj;
5621 wxRect *arg1 = (wxRect *) 0 ;
5622 int arg2 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char *kwnames[] = {
5626 (char *) "self",(char *) "right", NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(1)) SWIG_fail;
5632 {
5633 arg2 = (int)(SWIG_As_int(obj1));
5634 if (SWIG_arg_fail(2)) SWIG_fail;
5635 }
5636 {
5637 PyThreadState* __tstate = wxPyBeginAllowThreads();
5638 (arg1)->SetRight(arg2);
5639
5640 wxPyEndAllowThreads(__tstate);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 Py_INCREF(Py_None); resultobj = Py_None;
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 wxRect *arg1 = (wxRect *) 0 ;
5653 int arg2 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 char *kwnames[] = {
5657 (char *) "self",(char *) "top", NULL
5658 };
5659
5660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5662 if (SWIG_arg_fail(1)) SWIG_fail;
5663 {
5664 arg2 = (int)(SWIG_As_int(obj1));
5665 if (SWIG_arg_fail(2)) SWIG_fail;
5666 }
5667 {
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 (arg1)->SetTop(arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxRect *arg1 = (wxRect *) 0 ;
5684 int arg2 ;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 char *kwnames[] = {
5688 (char *) "self",(char *) "bottom", NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5693 if (SWIG_arg_fail(1)) SWIG_fail;
5694 {
5695 arg2 = (int)(SWIG_As_int(obj1));
5696 if (SWIG_arg_fail(2)) SWIG_fail;
5697 }
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 (arg1)->SetBottom(arg2);
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 Py_INCREF(Py_None); resultobj = Py_None;
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 wxRect *arg1 = (wxRect *) 0 ;
5715 int arg2 ;
5716 int arg3 ;
5717 wxRect *result;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 PyObject * obj2 = 0 ;
5721 char *kwnames[] = {
5722 (char *) "self",(char *) "dx",(char *) "dy", NULL
5723 };
5724
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5727 if (SWIG_arg_fail(1)) SWIG_fail;
5728 {
5729 arg2 = (int)(SWIG_As_int(obj1));
5730 if (SWIG_arg_fail(2)) SWIG_fail;
5731 }
5732 {
5733 arg3 = (int)(SWIG_As_int(obj2));
5734 if (SWIG_arg_fail(3)) SWIG_fail;
5735 }
5736 {
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 {
5739 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5740 result = (wxRect *) &_result_ref;
5741 }
5742
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj;
5755 wxRect *arg1 = (wxRect *) 0 ;
5756 int arg2 ;
5757 int arg3 ;
5758 wxRect *result;
5759 PyObject * obj0 = 0 ;
5760 PyObject * obj1 = 0 ;
5761 PyObject * obj2 = 0 ;
5762 char *kwnames[] = {
5763 (char *) "self",(char *) "dx",(char *) "dy", NULL
5764 };
5765
5766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5768 if (SWIG_arg_fail(1)) SWIG_fail;
5769 {
5770 arg2 = (int)(SWIG_As_int(obj1));
5771 if (SWIG_arg_fail(2)) SWIG_fail;
5772 }
5773 {
5774 arg3 = (int)(SWIG_As_int(obj2));
5775 if (SWIG_arg_fail(3)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 {
5780 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5781 result = (wxRect *) &_result_ref;
5782 }
5783
5784 wxPyEndAllowThreads(__tstate);
5785 if (PyErr_Occurred()) SWIG_fail;
5786 }
5787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj;
5796 wxRect *arg1 = (wxRect *) 0 ;
5797 int arg2 ;
5798 int arg3 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 PyObject * obj2 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self",(char *) "dx",(char *) "dy", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 arg2 = (int)(SWIG_As_int(obj1));
5811 if (SWIG_arg_fail(2)) SWIG_fail;
5812 }
5813 {
5814 arg3 = (int)(SWIG_As_int(obj2));
5815 if (SWIG_arg_fail(3)) SWIG_fail;
5816 }
5817 {
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 (arg1)->Offset(arg2,arg3);
5820
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 Py_INCREF(Py_None); resultobj = Py_None;
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxRect *arg1 = (wxRect *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char *kwnames[] = {
5839 (char *) "self",(char *) "pt", NULL
5840 };
5841
5842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 {
5846 arg2 = &temp2;
5847 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 (arg1)->Offset((wxPoint const &)*arg2);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 Py_INCREF(Py_None); resultobj = Py_None;
5857 return resultobj;
5858 fail:
5859 return NULL;
5860 }
5861
5862
5863 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5864 PyObject *resultobj;
5865 wxRect *arg1 = (wxRect *) 0 ;
5866 wxRect *arg2 = 0 ;
5867 wxRect result;
5868 wxRect temp2 ;
5869 PyObject * obj0 = 0 ;
5870 PyObject * obj1 = 0 ;
5871 char *kwnames[] = {
5872 (char *) "self",(char *) "rect", NULL
5873 };
5874
5875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5877 if (SWIG_arg_fail(1)) SWIG_fail;
5878 {
5879 arg2 = &temp2;
5880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 result = (arg1)->Intersect((wxRect const &)*arg2);
5885
5886 wxPyEndAllowThreads(__tstate);
5887 if (PyErr_Occurred()) SWIG_fail;
5888 }
5889 {
5890 wxRect * resultptr;
5891 resultptr = new wxRect((wxRect &)(result));
5892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5893 }
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxRect *arg1 = (wxRect *) 0 ;
5903 wxRect *arg2 = 0 ;
5904 wxRect result;
5905 wxRect temp2 ;
5906 PyObject * obj0 = 0 ;
5907 PyObject * obj1 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "self",(char *) "rect", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5914 if (SWIG_arg_fail(1)) SWIG_fail;
5915 {
5916 arg2 = &temp2;
5917 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5918 }
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (arg1)->Union((wxRect const &)*arg2);
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 wxRect * resultptr;
5928 resultptr = new wxRect((wxRect &)(result));
5929 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5930 }
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxRect *arg1 = (wxRect *) 0 ;
5940 wxRect *arg2 = 0 ;
5941 wxRect result;
5942 wxRect temp2 ;
5943 PyObject * obj0 = 0 ;
5944 PyObject * obj1 = 0 ;
5945 char *kwnames[] = {
5946 (char *) "self",(char *) "rect", NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 {
5953 arg2 = &temp2;
5954 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5955 }
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5959
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 {
5964 wxRect * resultptr;
5965 resultptr = new wxRect((wxRect &)(result));
5966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5967 }
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxRect *arg1 = (wxRect *) 0 ;
5977 wxRect *arg2 = 0 ;
5978 wxRect *result;
5979 wxRect temp2 ;
5980 PyObject * obj0 = 0 ;
5981 PyObject * obj1 = 0 ;
5982 char *kwnames[] = {
5983 (char *) "self",(char *) "rect", NULL
5984 };
5985
5986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5988 if (SWIG_arg_fail(1)) SWIG_fail;
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 {
5996 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5997 result = (wxRect *) &_result_ref;
5998 }
5999
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj;
6012 wxRect *arg1 = (wxRect *) 0 ;
6013 wxRect *arg2 = 0 ;
6014 bool result;
6015 wxRect temp2 ;
6016 PyObject * obj0 = 0 ;
6017 PyObject * obj1 = 0 ;
6018 char *kwnames[] = {
6019 (char *) "self",(char *) "rect", NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6024 if (SWIG_arg_fail(1)) SWIG_fail;
6025 {
6026 arg2 = &temp2;
6027 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6028 }
6029 {
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 {
6037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6038 }
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj;
6047 wxRect *arg1 = (wxRect *) 0 ;
6048 wxRect *arg2 = 0 ;
6049 bool result;
6050 wxRect temp2 ;
6051 PyObject * obj0 = 0 ;
6052 PyObject * obj1 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "self",(char *) "rect", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 {
6061 arg2 = &temp2;
6062 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6063 }
6064 {
6065 PyThreadState* __tstate = wxPyBeginAllowThreads();
6066 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6067
6068 wxPyEndAllowThreads(__tstate);
6069 if (PyErr_Occurred()) SWIG_fail;
6070 }
6071 {
6072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6073 }
6074 return resultobj;
6075 fail:
6076 return NULL;
6077 }
6078
6079
6080 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj;
6082 wxRect *arg1 = (wxRect *) 0 ;
6083 int arg2 ;
6084 int arg3 ;
6085 bool result;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "self",(char *) "x",(char *) "y", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6095 if (SWIG_arg_fail(1)) SWIG_fail;
6096 {
6097 arg2 = (int)(SWIG_As_int(obj1));
6098 if (SWIG_arg_fail(2)) SWIG_fail;
6099 }
6100 {
6101 arg3 = (int)(SWIG_As_int(obj2));
6102 if (SWIG_arg_fail(3)) SWIG_fail;
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6107
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 wxPoint *arg2 = 0 ;
6124 bool result;
6125 wxPoint temp2 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self",(char *) "pt", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 arg2 = &temp2;
6137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6142
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 {
6147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 wxRect *arg2 = 0 ;
6159 bool result;
6160 wxRect temp2 ;
6161 PyObject * obj0 = 0 ;
6162 PyObject * obj1 = 0 ;
6163 char *kwnames[] = {
6164 (char *) "self",(char *) "rect", NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6177
6178 wxPyEndAllowThreads(__tstate);
6179 if (PyErr_Occurred()) SWIG_fail;
6180 }
6181 {
6182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6183 }
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxRect *arg1 = (wxRect *) 0 ;
6193 int arg2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char *kwnames[] = {
6197 (char *) "self",(char *) "x", NULL
6198 };
6199
6200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 {
6204 arg2 = (int)(SWIG_As_int(obj1));
6205 if (SWIG_arg_fail(2)) SWIG_fail;
6206 }
6207 if (arg1) (arg1)->x = arg2;
6208
6209 Py_INCREF(Py_None); resultobj = Py_None;
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj;
6218 wxRect *arg1 = (wxRect *) 0 ;
6219 int result;
6220 PyObject * obj0 = 0 ;
6221 char *kwnames[] = {
6222 (char *) "self", NULL
6223 };
6224
6225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6227 if (SWIG_arg_fail(1)) SWIG_fail;
6228 result = (int) ((arg1)->x);
6229
6230 {
6231 resultobj = SWIG_From_int((int)(result));
6232 }
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int arg2 ;
6243 PyObject * obj0 = 0 ;
6244 PyObject * obj1 = 0 ;
6245 char *kwnames[] = {
6246 (char *) "self",(char *) "y", NULL
6247 };
6248
6249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6251 if (SWIG_arg_fail(1)) SWIG_fail;
6252 {
6253 arg2 = (int)(SWIG_As_int(obj1));
6254 if (SWIG_arg_fail(2)) SWIG_fail;
6255 }
6256 if (arg1) (arg1)->y = arg2;
6257
6258 Py_INCREF(Py_None); resultobj = Py_None;
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int result;
6269 PyObject * obj0 = 0 ;
6270 char *kwnames[] = {
6271 (char *) "self", NULL
6272 };
6273
6274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6276 if (SWIG_arg_fail(1)) SWIG_fail;
6277 result = (int) ((arg1)->y);
6278
6279 {
6280 resultobj = SWIG_From_int((int)(result));
6281 }
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 int arg2 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self",(char *) "width", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 {
6302 arg2 = (int)(SWIG_As_int(obj1));
6303 if (SWIG_arg_fail(2)) SWIG_fail;
6304 }
6305 if (arg1) (arg1)->width = arg2;
6306
6307 Py_INCREF(Py_None); resultobj = Py_None;
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int result;
6318 PyObject * obj0 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "self", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6325 if (SWIG_arg_fail(1)) SWIG_fail;
6326 result = (int) ((arg1)->width);
6327
6328 {
6329 resultobj = SWIG_From_int((int)(result));
6330 }
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int arg2 ;
6341 PyObject * obj0 = 0 ;
6342 PyObject * obj1 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "self",(char *) "height", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6349 if (SWIG_arg_fail(1)) SWIG_fail;
6350 {
6351 arg2 = (int)(SWIG_As_int(obj1));
6352 if (SWIG_arg_fail(2)) SWIG_fail;
6353 }
6354 if (arg1) (arg1)->height = arg2;
6355
6356 Py_INCREF(Py_None); resultobj = Py_None;
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 wxRect *arg1 = (wxRect *) 0 ;
6366 int result;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "self", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6374 if (SWIG_arg_fail(1)) SWIG_fail;
6375 result = (int) ((arg1)->height);
6376
6377 {
6378 resultobj = SWIG_From_int((int)(result));
6379 }
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int arg2 = (int) 0 ;
6390 int arg3 = (int) 0 ;
6391 int arg4 = (int) 0 ;
6392 int arg5 = (int) 0 ;
6393 PyObject * obj0 = 0 ;
6394 PyObject * obj1 = 0 ;
6395 PyObject * obj2 = 0 ;
6396 PyObject * obj3 = 0 ;
6397 PyObject * obj4 = 0 ;
6398 char *kwnames[] = {
6399 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6400 };
6401
6402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6404 if (SWIG_arg_fail(1)) SWIG_fail;
6405 if (obj1) {
6406 {
6407 arg2 = (int)(SWIG_As_int(obj1));
6408 if (SWIG_arg_fail(2)) SWIG_fail;
6409 }
6410 }
6411 if (obj2) {
6412 {
6413 arg3 = (int)(SWIG_As_int(obj2));
6414 if (SWIG_arg_fail(3)) SWIG_fail;
6415 }
6416 }
6417 if (obj3) {
6418 {
6419 arg4 = (int)(SWIG_As_int(obj3));
6420 if (SWIG_arg_fail(4)) SWIG_fail;
6421 }
6422 }
6423 if (obj4) {
6424 {
6425 arg5 = (int)(SWIG_As_int(obj4));
6426 if (SWIG_arg_fail(5)) SWIG_fail;
6427 }
6428 }
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 Py_INCREF(Py_None); resultobj = Py_None;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj;
6445 wxRect *arg1 = (wxRect *) 0 ;
6446 PyObject *result;
6447 PyObject * obj0 = 0 ;
6448 char *kwnames[] = {
6449 (char *) "self", NULL
6450 };
6451
6452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6454 if (SWIG_arg_fail(1)) SWIG_fail;
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (PyObject *)wxRect_Get(arg1);
6458
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = result;
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6470 PyObject *obj;
6471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6472 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6473 Py_INCREF(obj);
6474 return Py_BuildValue((char *)"");
6475 }
6476 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 wxRect *arg2 = (wxRect *) 0 ;
6480 PyObject *result;
6481 PyObject * obj0 = 0 ;
6482 PyObject * obj1 = 0 ;
6483 char *kwnames[] = {
6484 (char *) "r1",(char *) "r2", NULL
6485 };
6486
6487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6489 if (SWIG_arg_fail(1)) SWIG_fail;
6490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(2)) SWIG_fail;
6492 {
6493 if (!wxPyCheckForApp()) SWIG_fail;
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (PyObject *)wxIntersectRect(arg1,arg2);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = result;
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 double arg1 = (double) 0.0 ;
6510 double arg2 = (double) 0.0 ;
6511 wxPoint2D *result;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char *kwnames[] = {
6515 (char *) "x",(char *) "y", NULL
6516 };
6517
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6519 if (obj0) {
6520 {
6521 arg1 = (double)(SWIG_As_double(obj0));
6522 if (SWIG_arg_fail(1)) SWIG_fail;
6523 }
6524 }
6525 if (obj1) {
6526 {
6527 arg2 = (double)(SWIG_As_double(obj1));
6528 if (SWIG_arg_fail(2)) SWIG_fail;
6529 }
6530 }
6531 {
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6534
6535 wxPyEndAllowThreads(__tstate);
6536 if (PyErr_Occurred()) SWIG_fail;
6537 }
6538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxPoint2D *arg1 = 0 ;
6548 wxPoint2D *result;
6549 wxPoint2D temp1 ;
6550 PyObject * obj0 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "pt", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6556 {
6557 arg1 = &temp1;
6558 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6559 }
6560 {
6561 PyThreadState* __tstate = wxPyBeginAllowThreads();
6562 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6563
6564 wxPyEndAllowThreads(__tstate);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6575 PyObject *resultobj;
6576 wxPoint *arg1 = 0 ;
6577 wxPoint2D *result;
6578 wxPoint temp1 ;
6579 PyObject * obj0 = 0 ;
6580 char *kwnames[] = {
6581 (char *) "pt", NULL
6582 };
6583
6584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6585 {
6586 arg1 = &temp1;
6587 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6588 }
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6592
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6604 PyObject *resultobj;
6605 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6606 int *arg2 = (int *) 0 ;
6607 int *arg3 = (int *) 0 ;
6608 int temp2 ;
6609 int res2 = 0 ;
6610 int temp3 ;
6611 int res3 = 0 ;
6612 PyObject * obj0 = 0 ;
6613 char *kwnames[] = {
6614 (char *) "self", NULL
6615 };
6616
6617 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6618 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6621 if (SWIG_arg_fail(1)) SWIG_fail;
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6625
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 Py_INCREF(Py_None); resultobj = Py_None;
6630 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6631 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6632 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6633 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj;
6642 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6643 int *arg2 = (int *) 0 ;
6644 int *arg3 = (int *) 0 ;
6645 int temp2 ;
6646 int res2 = 0 ;
6647 int temp3 ;
6648 int res3 = 0 ;
6649 PyObject * obj0 = 0 ;
6650 char *kwnames[] = {
6651 (char *) "self", NULL
6652 };
6653
6654 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6655 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 Py_INCREF(Py_None); resultobj = Py_None;
6667 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6668 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6669 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6670 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6680 double result;
6681 PyObject * obj0 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 {
6697 resultobj = SWIG_From_double((double)(result));
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj;
6707 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6708 double result;
6709 PyObject * obj0 = 0 ;
6710 char *kwnames[] = {
6711 (char *) "self", NULL
6712 };
6713
6714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6716 if (SWIG_arg_fail(1)) SWIG_fail;
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6720
6721 wxPyEndAllowThreads(__tstate);
6722 if (PyErr_Occurred()) SWIG_fail;
6723 }
6724 {
6725 resultobj = SWIG_From_double((double)(result));
6726 }
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6734 PyObject *resultobj;
6735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6736 double arg2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "self",(char *) "length", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 {
6747 arg2 = (double)(SWIG_As_double(obj1));
6748 if (SWIG_arg_fail(2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetVectorLength(arg2);
6753
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 Py_INCREF(Py_None); resultobj = Py_None;
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj;
6766 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6767 double arg2 ;
6768 PyObject * obj0 = 0 ;
6769 PyObject * obj1 = 0 ;
6770 char *kwnames[] = {
6771 (char *) "self",(char *) "degrees", NULL
6772 };
6773
6774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) 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 arg2 = (double)(SWIG_As_double(obj1));
6779 if (SWIG_arg_fail(2)) SWIG_fail;
6780 }
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 (arg1)->SetVectorAngle(arg2);
6784
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 Py_INCREF(Py_None); resultobj = Py_None;
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj;
6797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6798 wxPoint2D *arg2 = 0 ;
6799 double result;
6800 wxPoint2D temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self",(char *) "pt", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6817
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 {
6822 resultobj = SWIG_From_double((double)(result));
6823 }
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj;
6832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6833 wxPoint2D *arg2 = 0 ;
6834 double result;
6835 wxPoint2D temp2 ;
6836 PyObject * obj0 = 0 ;
6837 PyObject * obj1 = 0 ;
6838 char *kwnames[] = {
6839 (char *) "self",(char *) "pt", NULL
6840 };
6841
6842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6844 if (SWIG_arg_fail(1)) SWIG_fail;
6845 {
6846 arg2 = &temp2;
6847 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6848 }
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6852
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = SWIG_From_double((double)(result));
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6868 wxPoint2D *arg2 = 0 ;
6869 double result;
6870 wxPoint2D temp2 ;
6871 PyObject * obj0 = 0 ;
6872 PyObject * obj1 = 0 ;
6873 char *kwnames[] = {
6874 (char *) "self",(char *) "vec", NULL
6875 };
6876
6877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6879 if (SWIG_arg_fail(1)) SWIG_fail;
6880 {
6881 arg2 = &temp2;
6882 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6883 }
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6887
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 {
6892 resultobj = SWIG_From_double((double)(result));
6893 }
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj;
6902 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6903 wxPoint2D *arg2 = 0 ;
6904 double result;
6905 wxPoint2D temp2 ;
6906 PyObject * obj0 = 0 ;
6907 PyObject * obj1 = 0 ;
6908 char *kwnames[] = {
6909 (char *) "self",(char *) "vec", NULL
6910 };
6911
6912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6914 if (SWIG_arg_fail(1)) SWIG_fail;
6915 {
6916 arg2 = &temp2;
6917 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6918 }
6919 {
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6922
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 {
6927 resultobj = SWIG_From_double((double)(result));
6928 }
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj;
6937 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6938 wxPoint2D result;
6939 PyObject * obj0 = 0 ;
6940 char *kwnames[] = {
6941 (char *) "self", NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (arg1)->operator -();
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 wxPoint2D * resultptr;
6956 resultptr = new wxPoint2D((wxPoint2D &)(result));
6957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6958 }
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D *arg2 = 0 ;
6969 wxPoint2D *result;
6970 wxPoint2D temp2 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "pt", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 {
6981 arg2 = &temp2;
6982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 {
6987 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6988 result = (wxPoint2D *) &_result_ref;
6989 }
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj;
7003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7004 wxPoint2D *arg2 = 0 ;
7005 wxPoint2D *result;
7006 wxPoint2D temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char *kwnames[] = {
7010 (char *) "self",(char *) "pt", NULL
7011 };
7012
7013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7015 if (SWIG_arg_fail(1)) SWIG_fail;
7016 {
7017 arg2 = &temp2;
7018 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7019 }
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 {
7023 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7024 result = (wxPoint2D *) &_result_ref;
7025 }
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7040 wxPoint2D *arg2 = 0 ;
7041 wxPoint2D *result;
7042 wxPoint2D temp2 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "pt", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 arg2 = &temp2;
7054 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7055 }
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 {
7059 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7060 result = (wxPoint2D *) &_result_ref;
7061 }
7062
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7076 wxPoint2D *arg2 = 0 ;
7077 wxPoint2D *result;
7078 wxPoint2D temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7087 if (SWIG_arg_fail(1)) SWIG_fail;
7088 {
7089 arg2 = &temp2;
7090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7091 }
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 {
7095 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7096 result = (wxPoint2D *) &_result_ref;
7097 }
7098
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7110 PyObject *resultobj;
7111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7112 wxPoint2D *arg2 = 0 ;
7113 bool result;
7114 wxPoint2D temp2 ;
7115 PyObject * obj0 = 0 ;
7116 PyObject * obj1 = 0 ;
7117 char *kwnames[] = {
7118 (char *) "self",(char *) "pt", NULL
7119 };
7120
7121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7123 if (SWIG_arg_fail(1)) SWIG_fail;
7124 {
7125 arg2 = &temp2;
7126 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7127 }
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7131
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7147 wxPoint2D *arg2 = 0 ;
7148 bool result;
7149 wxPoint2D temp2 ;
7150 PyObject * obj0 = 0 ;
7151 PyObject * obj1 = 0 ;
7152 char *kwnames[] = {
7153 (char *) "self",(char *) "pt", NULL
7154 };
7155
7156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(1)) SWIG_fail;
7159 {
7160 arg2 = &temp2;
7161 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7162 }
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7166
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 {
7171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7172 }
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj;
7181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7182 double arg2 ;
7183 PyObject * obj0 = 0 ;
7184 PyObject * obj1 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self",(char *) "m_x", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 {
7193 arg2 = (double)(SWIG_As_double(obj1));
7194 if (SWIG_arg_fail(2)) SWIG_fail;
7195 }
7196 if (arg1) (arg1)->m_x = arg2;
7197
7198 Py_INCREF(Py_None); resultobj = Py_None;
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj;
7207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7208 double result;
7209 PyObject * obj0 = 0 ;
7210 char *kwnames[] = {
7211 (char *) "self", NULL
7212 };
7213
7214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7216 if (SWIG_arg_fail(1)) SWIG_fail;
7217 result = (double) ((arg1)->m_x);
7218
7219 {
7220 resultobj = SWIG_From_double((double)(result));
7221 }
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj;
7230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7231 double arg2 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char *kwnames[] = {
7235 (char *) "self",(char *) "m_y", NULL
7236 };
7237
7238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7240 if (SWIG_arg_fail(1)) SWIG_fail;
7241 {
7242 arg2 = (double)(SWIG_As_double(obj1));
7243 if (SWIG_arg_fail(2)) SWIG_fail;
7244 }
7245 if (arg1) (arg1)->m_y = arg2;
7246
7247 Py_INCREF(Py_None); resultobj = Py_None;
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj;
7256 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7257 double result;
7258 PyObject * obj0 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "self", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(1)) SWIG_fail;
7266 result = (double) ((arg1)->m_y);
7267
7268 {
7269 resultobj = SWIG_From_double((double)(result));
7270 }
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7280 double arg2 = (double) 0 ;
7281 double arg3 = (double) 0 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 PyObject * obj2 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self",(char *) "x",(char *) "y", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 if (obj1) {
7293 {
7294 arg2 = (double)(SWIG_As_double(obj1));
7295 if (SWIG_arg_fail(2)) SWIG_fail;
7296 }
7297 }
7298 if (obj2) {
7299 {
7300 arg3 = (double)(SWIG_As_double(obj2));
7301 if (SWIG_arg_fail(3)) SWIG_fail;
7302 }
7303 }
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 wxPoint2D_Set(arg1,arg2,arg3);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 Py_INCREF(Py_None); resultobj = Py_None;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj;
7320 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7321 PyObject *result;
7322 PyObject * obj0 = 0 ;
7323 char *kwnames[] = {
7324 (char *) "self", NULL
7325 };
7326
7327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7329 if (SWIG_arg_fail(1)) SWIG_fail;
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (PyObject *)wxPoint2D_Get(arg1);
7333
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 resultobj = result;
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7345 PyObject *obj;
7346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7347 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7348 Py_INCREF(obj);
7349 return Py_BuildValue((char *)"");
7350 }
7351 static int _wrap_DefaultPosition_set(PyObject *) {
7352 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7353 return 1;
7354 }
7355
7356
7357 static PyObject *_wrap_DefaultPosition_get(void) {
7358 PyObject *pyobj;
7359
7360 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7361 return pyobj;
7362 }
7363
7364
7365 static int _wrap_DefaultSize_set(PyObject *) {
7366 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7367 return 1;
7368 }
7369
7370
7371 static PyObject *_wrap_DefaultSize_get(void) {
7372 PyObject *pyobj;
7373
7374 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7375 return pyobj;
7376 }
7377
7378
7379 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7380 PyObject *resultobj;
7381 PyObject *arg1 = (PyObject *) 0 ;
7382 wxPyInputStream *result;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "p", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7389 arg1 = obj0;
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj;
7406 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7407 PyObject * obj0 = 0 ;
7408 char *kwnames[] = {
7409 (char *) "self", NULL
7410 };
7411
7412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7414 if (SWIG_arg_fail(1)) SWIG_fail;
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 delete arg1;
7418
7419 wxPyEndAllowThreads(__tstate);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 Py_INCREF(Py_None); resultobj = Py_None;
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7432 PyObject * obj0 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 (arg1)->close();
7443
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 Py_INCREF(Py_None); resultobj = Py_None;
7448 return resultobj;
7449 fail:
7450 return NULL;
7451 }
7452
7453
7454 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7455 PyObject *resultobj;
7456 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 (arg1)->flush();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 Py_INCREF(Py_None); resultobj = Py_None;
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj;
7481 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7482 bool result;
7483 PyObject * obj0 = 0 ;
7484 char *kwnames[] = {
7485 (char *) "self", NULL
7486 };
7487
7488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7490 if (SWIG_arg_fail(1)) SWIG_fail;
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (bool)(arg1)->eof();
7494
7495 wxPyEndAllowThreads(__tstate);
7496 if (PyErr_Occurred()) SWIG_fail;
7497 }
7498 {
7499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7500 }
7501 return resultobj;
7502 fail:
7503 return NULL;
7504 }
7505
7506
7507 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7508 PyObject *resultobj;
7509 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7510 int arg2 = (int) -1 ;
7511 PyObject *result;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self",(char *) "size", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7520 if (SWIG_arg_fail(1)) SWIG_fail;
7521 if (obj1) {
7522 {
7523 arg2 = (int)(SWIG_As_int(obj1));
7524 if (SWIG_arg_fail(2)) SWIG_fail;
7525 }
7526 }
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 result = (PyObject *)(arg1)->read(arg2);
7530
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 resultobj = result;
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj;
7543 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7544 int arg2 = (int) -1 ;
7545 PyObject *result;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char *kwnames[] = {
7549 (char *) "self",(char *) "size", NULL
7550 };
7551
7552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7554 if (SWIG_arg_fail(1)) SWIG_fail;
7555 if (obj1) {
7556 {
7557 arg2 = (int)(SWIG_As_int(obj1));
7558 if (SWIG_arg_fail(2)) SWIG_fail;
7559 }
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (PyObject *)(arg1)->readline(arg2);
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = result;
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj;
7577 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7578 int arg2 = (int) -1 ;
7579 PyObject *result;
7580 PyObject * obj0 = 0 ;
7581 PyObject * obj1 = 0 ;
7582 char *kwnames[] = {
7583 (char *) "self",(char *) "sizehint", NULL
7584 };
7585
7586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7588 if (SWIG_arg_fail(1)) SWIG_fail;
7589 if (obj1) {
7590 {
7591 arg2 = (int)(SWIG_As_int(obj1));
7592 if (SWIG_arg_fail(2)) SWIG_fail;
7593 }
7594 }
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 result = (PyObject *)(arg1)->readlines(arg2);
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 resultobj = result;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7612 int arg2 ;
7613 int arg3 = (int) 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self",(char *) "offset",(char *) "whence", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 {
7625 arg2 = (int)(SWIG_As_int(obj1));
7626 if (SWIG_arg_fail(2)) SWIG_fail;
7627 }
7628 if (obj2) {
7629 {
7630 arg3 = (int)(SWIG_As_int(obj2));
7631 if (SWIG_arg_fail(3)) SWIG_fail;
7632 }
7633 }
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 (arg1)->seek(arg2,arg3);
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 Py_INCREF(Py_None); resultobj = Py_None;
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj;
7650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7651 int result;
7652 PyObject * obj0 = 0 ;
7653 char *kwnames[] = {
7654 (char *) "self", NULL
7655 };
7656
7657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(1)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (int)(arg1)->tell();
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = SWIG_From_int((int)(result));
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 char result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (char)(arg1)->Peek();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = SWIG_From_char((char)(result));
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 char result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (char)(arg1)->GetC();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = SWIG_From_char((char)(result));
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 size_t result;
7736 PyObject * obj0 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "self", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (size_t)(arg1)->LastRead();
7747
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 {
7752 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7763 bool result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (bool)(arg1)->CanRead();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj;
7790 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7791 bool result;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 result = (bool)(arg1)->Eof();
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7819 char arg2 ;
7820 bool result;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "self",(char *) "c", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7829 if (SWIG_arg_fail(1)) SWIG_fail;
7830 {
7831 arg2 = (char)(SWIG_As_char(obj1));
7832 if (SWIG_arg_fail(2)) SWIG_fail;
7833 }
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (bool)(arg1)->Ungetch(arg2);
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 long arg2 ;
7854 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7855 long result;
7856 PyObject * obj0 = 0 ;
7857 PyObject * obj1 = 0 ;
7858 PyObject * obj2 = 0 ;
7859 char *kwnames[] = {
7860 (char *) "self",(char *) "pos",(char *) "mode", NULL
7861 };
7862
7863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7865 if (SWIG_arg_fail(1)) SWIG_fail;
7866 {
7867 arg2 = (long)(SWIG_As_long(obj1));
7868 if (SWIG_arg_fail(2)) SWIG_fail;
7869 }
7870 if (obj2) {
7871 {
7872 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7873 if (SWIG_arg_fail(3)) SWIG_fail;
7874 }
7875 }
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 {
7884 resultobj = SWIG_From_long((long)(result));
7885 }
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7895 long result;
7896 PyObject * obj0 = 0 ;
7897 char *kwnames[] = {
7898 (char *) "self", NULL
7899 };
7900
7901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7903 if (SWIG_arg_fail(1)) SWIG_fail;
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (long)(arg1)->TellI();
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 {
7912 resultobj = SWIG_From_long((long)(result));
7913 }
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7921 PyObject *obj;
7922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7923 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7924 Py_INCREF(obj);
7925 return Py_BuildValue((char *)"");
7926 }
7927 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7928 PyObject *resultobj;
7929 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7930 PyObject *arg2 = (PyObject *) 0 ;
7931 PyObject * obj0 = 0 ;
7932 PyObject * obj1 = 0 ;
7933 char *kwnames[] = {
7934 (char *) "self",(char *) "obj", NULL
7935 };
7936
7937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7939 if (SWIG_arg_fail(1)) SWIG_fail;
7940 arg2 = obj1;
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 wxOutputStream_write(arg1,arg2);
7944
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 Py_INCREF(Py_None); resultobj = Py_None;
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7956 PyObject *obj;
7957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7958 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7959 Py_INCREF(obj);
7960 return Py_BuildValue((char *)"");
7961 }
7962 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj;
7964 wxInputStream *arg1 = (wxInputStream *) 0 ;
7965 wxString *arg2 = 0 ;
7966 wxString *arg3 = 0 ;
7967 wxString *arg4 = 0 ;
7968 wxDateTime arg5 ;
7969 wxFSFile *result;
7970 wxPyInputStream *temp1 ;
7971 bool temp2 = false ;
7972 bool temp3 = false ;
7973 bool temp4 = false ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 PyObject * obj2 = 0 ;
7977 PyObject * obj3 = 0 ;
7978 PyObject * obj4 = 0 ;
7979 char *kwnames[] = {
7980 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7981 };
7982
7983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7984 {
7985 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7986 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7987 } else {
7988 PyErr_Clear(); // clear the failure of the wxPyConvert above
7989 arg1 = wxPyCBInputStream_create(obj0, true);
7990 if (arg1 == NULL) {
7991 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7992 SWIG_fail;
7993 }
7994 }
7995 }
7996 {
7997 arg2 = wxString_in_helper(obj1);
7998 if (arg2 == NULL) SWIG_fail;
7999 temp2 = true;
8000 }
8001 {
8002 arg3 = wxString_in_helper(obj2);
8003 if (arg3 == NULL) SWIG_fail;
8004 temp3 = true;
8005 }
8006 {
8007 arg4 = wxString_in_helper(obj3);
8008 if (arg4 == NULL) SWIG_fail;
8009 temp4 = true;
8010 }
8011 {
8012 wxDateTime * argp;
8013 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8014 if (SWIG_arg_fail(5)) SWIG_fail;
8015 if (argp == NULL) {
8016 SWIG_null_ref("wxDateTime");
8017 }
8018 if (SWIG_arg_fail(5)) SWIG_fail;
8019 arg5 = *argp;
8020 }
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8024
8025 wxPyEndAllowThreads(__tstate);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 {
8029 resultobj = wxPyMake_wxObject(result, 1);
8030 }
8031 {
8032 if (temp2)
8033 delete arg2;
8034 }
8035 {
8036 if (temp3)
8037 delete arg3;
8038 }
8039 {
8040 if (temp4)
8041 delete arg4;
8042 }
8043 return resultobj;
8044 fail:
8045 {
8046 if (temp2)
8047 delete arg2;
8048 }
8049 {
8050 if (temp3)
8051 delete arg3;
8052 }
8053 {
8054 if (temp4)
8055 delete arg4;
8056 }
8057 return NULL;
8058 }
8059
8060
8061 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8062 PyObject *resultobj;
8063 wxFSFile *arg1 = (wxFSFile *) 0 ;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 delete arg1;
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 Py_INCREF(Py_None); resultobj = Py_None;
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj;
8088 wxFSFile *arg1 = (wxFSFile *) 0 ;
8089 wxInputStream *result;
8090 PyObject * obj0 = 0 ;
8091 char *kwnames[] = {
8092 (char *) "self", NULL
8093 };
8094
8095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8097 if (SWIG_arg_fail(1)) SWIG_fail;
8098 {
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 result = (wxInputStream *)(arg1)->GetStream();
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 wxPyInputStream * _ptr = NULL;
8107
8108 if (result) {
8109 _ptr = new wxPyInputStream(result);
8110 }
8111 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj;
8121 wxFSFile *arg1 = (wxFSFile *) 0 ;
8122 wxString *result;
8123 PyObject * obj0 = 0 ;
8124 char *kwnames[] = {
8125 (char *) "self", NULL
8126 };
8127
8128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8130 if (SWIG_arg_fail(1)) SWIG_fail;
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 {
8134 wxString const &_result_ref = (arg1)->GetMimeType();
8135 result = (wxString *) &_result_ref;
8136 }
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 {
8142 #if wxUSE_UNICODE
8143 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8144 #else
8145 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8146 #endif
8147 }
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxFSFile *arg1 = (wxFSFile *) 0 ;
8157 wxString *result;
8158 PyObject * obj0 = 0 ;
8159 char *kwnames[] = {
8160 (char *) "self", NULL
8161 };
8162
8163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8165 if (SWIG_arg_fail(1)) SWIG_fail;
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 {
8169 wxString const &_result_ref = (arg1)->GetLocation();
8170 result = (wxString *) &_result_ref;
8171 }
8172
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 #if wxUSE_UNICODE
8178 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8179 #else
8180 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8181 #endif
8182 }
8183 return resultobj;
8184 fail:
8185 return NULL;
8186 }
8187
8188
8189 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8190 PyObject *resultobj;
8191 wxFSFile *arg1 = (wxFSFile *) 0 ;
8192 wxString *result;
8193 PyObject * obj0 = 0 ;
8194 char *kwnames[] = {
8195 (char *) "self", NULL
8196 };
8197
8198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8200 if (SWIG_arg_fail(1)) SWIG_fail;
8201 {
8202 PyThreadState* __tstate = wxPyBeginAllowThreads();
8203 {
8204 wxString const &_result_ref = (arg1)->GetAnchor();
8205 result = (wxString *) &_result_ref;
8206 }
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 {
8212 #if wxUSE_UNICODE
8213 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8214 #else
8215 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8216 #endif
8217 }
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8225 PyObject *resultobj;
8226 wxFSFile *arg1 = (wxFSFile *) 0 ;
8227 wxDateTime result;
8228 PyObject * obj0 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 result = (arg1)->GetModificationTime();
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 {
8244 wxDateTime * resultptr;
8245 resultptr = new wxDateTime((wxDateTime &)(result));
8246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8247 }
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8255 PyObject *obj;
8256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8257 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8258 Py_INCREF(obj);
8259 return Py_BuildValue((char *)"");
8260 }
8261 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8262 PyObject *obj;
8263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8264 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8265 Py_INCREF(obj);
8266 return Py_BuildValue((char *)"");
8267 }
8268 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8269 PyObject *resultobj;
8270 wxPyFileSystemHandler *result;
8271 char *kwnames[] = {
8272 NULL
8273 };
8274
8275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8276 {
8277 PyThreadState* __tstate = wxPyBeginAllowThreads();
8278 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8279
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj;
8292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8293 PyObject *arg2 = (PyObject *) 0 ;
8294 PyObject *arg3 = (PyObject *) 0 ;
8295 PyObject * obj0 = 0 ;
8296 PyObject * obj1 = 0 ;
8297 PyObject * obj2 = 0 ;
8298 char *kwnames[] = {
8299 (char *) "self",(char *) "self",(char *) "_class", NULL
8300 };
8301
8302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8304 if (SWIG_arg_fail(1)) SWIG_fail;
8305 arg2 = obj1;
8306 arg3 = obj2;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 (arg1)->_setCallbackInfo(arg2,arg3);
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 Py_INCREF(Py_None); resultobj = Py_None;
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj;
8323 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8324 wxString *arg2 = 0 ;
8325 bool result;
8326 bool temp2 = false ;
8327 PyObject * obj0 = 0 ;
8328 PyObject * obj1 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self",(char *) "location", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 arg2 = wxString_in_helper(obj1);
8338 if (arg2 == NULL) SWIG_fail;
8339 temp2 = true;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8344
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 {
8349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8350 }
8351 {
8352 if (temp2)
8353 delete arg2;
8354 }
8355 return resultobj;
8356 fail:
8357 {
8358 if (temp2)
8359 delete arg2;
8360 }
8361 return NULL;
8362 }
8363
8364
8365 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj;
8367 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8368 wxFileSystem *arg2 = 0 ;
8369 wxString *arg3 = 0 ;
8370 wxFSFile *result;
8371 bool temp3 = false ;
8372 PyObject * obj0 = 0 ;
8373 PyObject * obj1 = 0 ;
8374 PyObject * obj2 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self",(char *) "fs",(char *) "location", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 {
8383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8384 if (SWIG_arg_fail(2)) SWIG_fail;
8385 if (arg2 == NULL) {
8386 SWIG_null_ref("wxFileSystem");
8387 }
8388 if (SWIG_arg_fail(2)) SWIG_fail;
8389 }
8390 {
8391 arg3 = wxString_in_helper(obj2);
8392 if (arg3 == NULL) SWIG_fail;
8393 temp3 = true;
8394 }
8395 {
8396 PyThreadState* __tstate = wxPyBeginAllowThreads();
8397 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8398
8399 wxPyEndAllowThreads(__tstate);
8400 if (PyErr_Occurred()) SWIG_fail;
8401 }
8402 {
8403 resultobj = wxPyMake_wxObject(result, 1);
8404 }
8405 {
8406 if (temp3)
8407 delete arg3;
8408 }
8409 return resultobj;
8410 fail:
8411 {
8412 if (temp3)
8413 delete arg3;
8414 }
8415 return NULL;
8416 }
8417
8418
8419 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj;
8421 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8422 wxString *arg2 = 0 ;
8423 int arg3 = (int) 0 ;
8424 wxString result;
8425 bool temp2 = false ;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 PyObject * obj2 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self",(char *) "spec",(char *) "flags", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 {
8437 arg2 = wxString_in_helper(obj1);
8438 if (arg2 == NULL) SWIG_fail;
8439 temp2 = true;
8440 }
8441 if (obj2) {
8442 {
8443 arg3 = (int)(SWIG_As_int(obj2));
8444 if (SWIG_arg_fail(3)) SWIG_fail;
8445 }
8446 }
8447 {
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8450
8451 wxPyEndAllowThreads(__tstate);
8452 if (PyErr_Occurred()) SWIG_fail;
8453 }
8454 {
8455 #if wxUSE_UNICODE
8456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8457 #else
8458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8459 #endif
8460 }
8461 {
8462 if (temp2)
8463 delete arg2;
8464 }
8465 return resultobj;
8466 fail:
8467 {
8468 if (temp2)
8469 delete arg2;
8470 }
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8478 wxString result;
8479 PyObject * obj0 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (arg1)->FindNext();
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 #if wxUSE_UNICODE
8496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8497 #else
8498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8499 #endif
8500 }
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj;
8509 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8510 wxString *arg2 = 0 ;
8511 wxString result;
8512 bool temp2 = false ;
8513 PyObject * obj0 = 0 ;
8514 PyObject * obj1 = 0 ;
8515 char *kwnames[] = {
8516 (char *) "self",(char *) "location", NULL
8517 };
8518
8519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8521 if (SWIG_arg_fail(1)) SWIG_fail;
8522 {
8523 arg2 = wxString_in_helper(obj1);
8524 if (arg2 == NULL) SWIG_fail;
8525 temp2 = true;
8526 }
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 result = (arg1)->GetProtocol((wxString const &)*arg2);
8530
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 #if wxUSE_UNICODE
8536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8537 #else
8538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8539 #endif
8540 }
8541 {
8542 if (temp2)
8543 delete arg2;
8544 }
8545 return resultobj;
8546 fail:
8547 {
8548 if (temp2)
8549 delete arg2;
8550 }
8551 return NULL;
8552 }
8553
8554
8555 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj;
8557 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8558 wxString *arg2 = 0 ;
8559 wxString result;
8560 bool temp2 = false ;
8561 PyObject * obj0 = 0 ;
8562 PyObject * obj1 = 0 ;
8563 char *kwnames[] = {
8564 (char *) "self",(char *) "location", NULL
8565 };
8566
8567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8569 if (SWIG_arg_fail(1)) SWIG_fail;
8570 {
8571 arg2 = wxString_in_helper(obj1);
8572 if (arg2 == NULL) SWIG_fail;
8573 temp2 = true;
8574 }
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 #if wxUSE_UNICODE
8584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8585 #else
8586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8587 #endif
8588 }
8589 {
8590 if (temp2)
8591 delete arg2;
8592 }
8593 return resultobj;
8594 fail:
8595 {
8596 if (temp2)
8597 delete arg2;
8598 }
8599 return NULL;
8600 }
8601
8602
8603 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8604 PyObject *resultobj;
8605 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8606 wxString *arg2 = 0 ;
8607 wxString result;
8608 bool temp2 = false ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 char *kwnames[] = {
8612 (char *) "self",(char *) "location", NULL
8613 };
8614
8615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8617 if (SWIG_arg_fail(1)) SWIG_fail;
8618 {
8619 arg2 = wxString_in_helper(obj1);
8620 if (arg2 == NULL) SWIG_fail;
8621 temp2 = true;
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 result = (arg1)->GetAnchor((wxString const &)*arg2);
8626
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 {
8631 #if wxUSE_UNICODE
8632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8633 #else
8634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8635 #endif
8636 }
8637 {
8638 if (temp2)
8639 delete arg2;
8640 }
8641 return resultobj;
8642 fail:
8643 {
8644 if (temp2)
8645 delete arg2;
8646 }
8647 return NULL;
8648 }
8649
8650
8651 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj;
8653 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8654 wxString *arg2 = 0 ;
8655 wxString result;
8656 bool temp2 = false ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char *kwnames[] = {
8660 (char *) "self",(char *) "location", NULL
8661 };
8662
8663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8665 if (SWIG_arg_fail(1)) SWIG_fail;
8666 {
8667 arg2 = wxString_in_helper(obj1);
8668 if (arg2 == NULL) SWIG_fail;
8669 temp2 = true;
8670 }
8671 {
8672 PyThreadState* __tstate = wxPyBeginAllowThreads();
8673 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8674
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 {
8679 #if wxUSE_UNICODE
8680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8681 #else
8682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8683 #endif
8684 }
8685 {
8686 if (temp2)
8687 delete arg2;
8688 }
8689 return resultobj;
8690 fail:
8691 {
8692 if (temp2)
8693 delete arg2;
8694 }
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj;
8701 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8702 wxString *arg2 = 0 ;
8703 wxString result;
8704 bool temp2 = false ;
8705 PyObject * obj0 = 0 ;
8706 PyObject * obj1 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "self",(char *) "location", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 {
8715 arg2 = wxString_in_helper(obj1);
8716 if (arg2 == NULL) SWIG_fail;
8717 temp2 = true;
8718 }
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8722
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 {
8727 #if wxUSE_UNICODE
8728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8729 #else
8730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8731 #endif
8732 }
8733 {
8734 if (temp2)
8735 delete arg2;
8736 }
8737 return resultobj;
8738 fail:
8739 {
8740 if (temp2)
8741 delete arg2;
8742 }
8743 return NULL;
8744 }
8745
8746
8747 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8748 PyObject *obj;
8749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8750 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8751 Py_INCREF(obj);
8752 return Py_BuildValue((char *)"");
8753 }
8754 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj;
8756 wxFileSystem *result;
8757 char *kwnames[] = {
8758 NULL
8759 };
8760
8761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 result = (wxFileSystem *)new wxFileSystem();
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 {
8770 resultobj = wxPyMake_wxObject(result, 1);
8771 }
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8779 PyObject *resultobj;
8780 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8781 PyObject * obj0 = 0 ;
8782 char *kwnames[] = {
8783 (char *) "self", NULL
8784 };
8785
8786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8788 if (SWIG_arg_fail(1)) SWIG_fail;
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 delete arg1;
8792
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 Py_INCREF(Py_None); resultobj = Py_None;
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj;
8805 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8806 wxString *arg2 = 0 ;
8807 bool arg3 = (bool) false ;
8808 bool temp2 = false ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 PyObject * obj2 = 0 ;
8812 char *kwnames[] = {
8813 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8814 };
8815
8816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8818 if (SWIG_arg_fail(1)) SWIG_fail;
8819 {
8820 arg2 = wxString_in_helper(obj1);
8821 if (arg2 == NULL) SWIG_fail;
8822 temp2 = true;
8823 }
8824 if (obj2) {
8825 {
8826 arg3 = (bool)(SWIG_As_bool(obj2));
8827 if (SWIG_arg_fail(3)) SWIG_fail;
8828 }
8829 }
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8833
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 Py_INCREF(Py_None); resultobj = Py_None;
8838 {
8839 if (temp2)
8840 delete arg2;
8841 }
8842 return resultobj;
8843 fail:
8844 {
8845 if (temp2)
8846 delete arg2;
8847 }
8848 return NULL;
8849 }
8850
8851
8852 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8853 PyObject *resultobj;
8854 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8855 wxString result;
8856 PyObject * obj0 = 0 ;
8857 char *kwnames[] = {
8858 (char *) "self", NULL
8859 };
8860
8861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8863 if (SWIG_arg_fail(1)) SWIG_fail;
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 result = (arg1)->GetPath();
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 {
8872 #if wxUSE_UNICODE
8873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8874 #else
8875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8876 #endif
8877 }
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8887 wxString *arg2 = 0 ;
8888 wxFSFile *result;
8889 bool temp2 = false ;
8890 PyObject * obj0 = 0 ;
8891 PyObject * obj1 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self",(char *) "location", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 {
8900 arg2 = wxString_in_helper(obj1);
8901 if (arg2 == NULL) SWIG_fail;
8902 temp2 = true;
8903 }
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8907
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 resultobj = wxPyMake_wxObject(result, 1);
8913 }
8914 {
8915 if (temp2)
8916 delete arg2;
8917 }
8918 return resultobj;
8919 fail:
8920 {
8921 if (temp2)
8922 delete arg2;
8923 }
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8931 wxString *arg2 = 0 ;
8932 int arg3 = (int) 0 ;
8933 wxString result;
8934 bool temp2 = false ;
8935 PyObject * obj0 = 0 ;
8936 PyObject * obj1 = 0 ;
8937 PyObject * obj2 = 0 ;
8938 char *kwnames[] = {
8939 (char *) "self",(char *) "spec",(char *) "flags", NULL
8940 };
8941
8942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8944 if (SWIG_arg_fail(1)) SWIG_fail;
8945 {
8946 arg2 = wxString_in_helper(obj1);
8947 if (arg2 == NULL) SWIG_fail;
8948 temp2 = true;
8949 }
8950 if (obj2) {
8951 {
8952 arg3 = (int)(SWIG_As_int(obj2));
8953 if (SWIG_arg_fail(3)) SWIG_fail;
8954 }
8955 }
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 {
8964 #if wxUSE_UNICODE
8965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8966 #else
8967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8968 #endif
8969 }
8970 {
8971 if (temp2)
8972 delete arg2;
8973 }
8974 return resultobj;
8975 fail:
8976 {
8977 if (temp2)
8978 delete arg2;
8979 }
8980 return NULL;
8981 }
8982
8983
8984 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj;
8986 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8987 wxString result;
8988 PyObject * obj0 = 0 ;
8989 char *kwnames[] = {
8990 (char *) "self", NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8995 if (SWIG_arg_fail(1)) SWIG_fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 result = (arg1)->FindNext();
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 {
9004 #if wxUSE_UNICODE
9005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9006 #else
9007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9008 #endif
9009 }
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj;
9018 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9019 PyObject * obj0 = 0 ;
9020 char *kwnames[] = {
9021 (char *) "handler", NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9026 if (SWIG_arg_fail(1)) SWIG_fail;
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 wxFileSystem::AddHandler(arg1);
9030
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 Py_INCREF(Py_None); resultobj = Py_None;
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 char *kwnames[] = {
9044 NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxFileSystem::CleanUpHandlers();
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxString *arg1 = 0 ;
9065 wxString result;
9066 bool temp1 = false ;
9067 PyObject * obj0 = 0 ;
9068 char *kwnames[] = {
9069 (char *) "filename", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9073 {
9074 arg1 = wxString_in_helper(obj0);
9075 if (arg1 == NULL) SWIG_fail;
9076 temp1 = true;
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9081
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 {
9086 #if wxUSE_UNICODE
9087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9088 #else
9089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9090 #endif
9091 }
9092 {
9093 if (temp1)
9094 delete arg1;
9095 }
9096 return resultobj;
9097 fail:
9098 {
9099 if (temp1)
9100 delete arg1;
9101 }
9102 return NULL;
9103 }
9104
9105
9106 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj;
9108 wxString *arg1 = 0 ;
9109 wxString result;
9110 bool temp1 = false ;
9111 PyObject * obj0 = 0 ;
9112 char *kwnames[] = {
9113 (char *) "url", NULL
9114 };
9115
9116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9117 {
9118 arg1 = wxString_in_helper(obj0);
9119 if (arg1 == NULL) SWIG_fail;
9120 temp1 = true;
9121 }
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 result = FileSystem_URLToFileName((wxString const &)*arg1);
9125
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 {
9130 #if wxUSE_UNICODE
9131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9132 #else
9133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9134 #endif
9135 }
9136 {
9137 if (temp1)
9138 delete arg1;
9139 }
9140 return resultobj;
9141 fail:
9142 {
9143 if (temp1)
9144 delete arg1;
9145 }
9146 return NULL;
9147 }
9148
9149
9150 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9151 PyObject *obj;
9152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9153 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9154 Py_INCREF(obj);
9155 return Py_BuildValue((char *)"");
9156 }
9157 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 wxInternetFSHandler *result;
9160 char *kwnames[] = {
9161 NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9168
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj;
9181 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9182 wxString *arg2 = 0 ;
9183 bool result;
9184 bool temp2 = false ;
9185 PyObject * obj0 = 0 ;
9186 PyObject * obj1 = 0 ;
9187 char *kwnames[] = {
9188 (char *) "self",(char *) "location", NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9193 if (SWIG_arg_fail(1)) SWIG_fail;
9194 {
9195 arg2 = wxString_in_helper(obj1);
9196 if (arg2 == NULL) SWIG_fail;
9197 temp2 = true;
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9208 }
9209 {
9210 if (temp2)
9211 delete arg2;
9212 }
9213 return resultobj;
9214 fail:
9215 {
9216 if (temp2)
9217 delete arg2;
9218 }
9219 return NULL;
9220 }
9221
9222
9223 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9226 wxFileSystem *arg2 = 0 ;
9227 wxString *arg3 = 0 ;
9228 wxFSFile *result;
9229 bool temp3 = false ;
9230 PyObject * obj0 = 0 ;
9231 PyObject * obj1 = 0 ;
9232 PyObject * obj2 = 0 ;
9233 char *kwnames[] = {
9234 (char *) "self",(char *) "fs",(char *) "location", NULL
9235 };
9236
9237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9239 if (SWIG_arg_fail(1)) SWIG_fail;
9240 {
9241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9242 if (SWIG_arg_fail(2)) SWIG_fail;
9243 if (arg2 == NULL) {
9244 SWIG_null_ref("wxFileSystem");
9245 }
9246 if (SWIG_arg_fail(2)) SWIG_fail;
9247 }
9248 {
9249 arg3 = wxString_in_helper(obj2);
9250 if (arg3 == NULL) SWIG_fail;
9251 temp3 = true;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 resultobj = wxPyMake_wxObject(result, 1);
9262 }
9263 {
9264 if (temp3)
9265 delete arg3;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp3)
9271 delete arg3;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9278 PyObject *obj;
9279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9280 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9281 Py_INCREF(obj);
9282 return Py_BuildValue((char *)"");
9283 }
9284 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj;
9286 wxZipFSHandler *result;
9287 char *kwnames[] = {
9288 NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (wxZipFSHandler *)new wxZipFSHandler();
9295
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9309 wxString *arg2 = 0 ;
9310 bool result;
9311 bool temp2 = false ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char *kwnames[] = {
9315 (char *) "self",(char *) "location", NULL
9316 };
9317
9318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9320 if (SWIG_arg_fail(1)) SWIG_fail;
9321 {
9322 arg2 = wxString_in_helper(obj1);
9323 if (arg2 == NULL) SWIG_fail;
9324 temp2 = true;
9325 }
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9329
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 {
9334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9335 }
9336 {
9337 if (temp2)
9338 delete arg2;
9339 }
9340 return resultobj;
9341 fail:
9342 {
9343 if (temp2)
9344 delete arg2;
9345 }
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9353 wxFileSystem *arg2 = 0 ;
9354 wxString *arg3 = 0 ;
9355 wxFSFile *result;
9356 bool temp3 = false ;
9357 PyObject * obj0 = 0 ;
9358 PyObject * obj1 = 0 ;
9359 PyObject * obj2 = 0 ;
9360 char *kwnames[] = {
9361 (char *) "self",(char *) "fs",(char *) "location", NULL
9362 };
9363
9364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9366 if (SWIG_arg_fail(1)) SWIG_fail;
9367 {
9368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9369 if (SWIG_arg_fail(2)) SWIG_fail;
9370 if (arg2 == NULL) {
9371 SWIG_null_ref("wxFileSystem");
9372 }
9373 if (SWIG_arg_fail(2)) SWIG_fail;
9374 }
9375 {
9376 arg3 = wxString_in_helper(obj2);
9377 if (arg3 == NULL) SWIG_fail;
9378 temp3 = true;
9379 }
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = wxPyMake_wxObject(result, 1);
9389 }
9390 {
9391 if (temp3)
9392 delete arg3;
9393 }
9394 return resultobj;
9395 fail:
9396 {
9397 if (temp3)
9398 delete arg3;
9399 }
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9407 wxString *arg2 = 0 ;
9408 int arg3 = (int) 0 ;
9409 wxString result;
9410 bool temp2 = false ;
9411 PyObject * obj0 = 0 ;
9412 PyObject * obj1 = 0 ;
9413 PyObject * obj2 = 0 ;
9414 char *kwnames[] = {
9415 (char *) "self",(char *) "spec",(char *) "flags", NULL
9416 };
9417
9418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9420 if (SWIG_arg_fail(1)) SWIG_fail;
9421 {
9422 arg2 = wxString_in_helper(obj1);
9423 if (arg2 == NULL) SWIG_fail;
9424 temp2 = true;
9425 }
9426 if (obj2) {
9427 {
9428 arg3 = (int)(SWIG_As_int(obj2));
9429 if (SWIG_arg_fail(3)) SWIG_fail;
9430 }
9431 }
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 {
9440 #if wxUSE_UNICODE
9441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9442 #else
9443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9444 #endif
9445 }
9446 {
9447 if (temp2)
9448 delete arg2;
9449 }
9450 return resultobj;
9451 fail:
9452 {
9453 if (temp2)
9454 delete arg2;
9455 }
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj;
9462 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9463 wxString result;
9464 PyObject * obj0 = 0 ;
9465 char *kwnames[] = {
9466 (char *) "self", NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9471 if (SWIG_arg_fail(1)) SWIG_fail;
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (arg1)->FindNext();
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 #if wxUSE_UNICODE
9481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9482 #else
9483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9484 #endif
9485 }
9486 return resultobj;
9487 fail:
9488 return NULL;
9489 }
9490
9491
9492 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9493 PyObject *obj;
9494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9495 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9496 Py_INCREF(obj);
9497 return Py_BuildValue((char *)"");
9498 }
9499 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9500 PyObject *resultobj;
9501 wxString *arg1 = 0 ;
9502 wxImage *arg2 = 0 ;
9503 long arg3 ;
9504 bool temp1 = false ;
9505 PyObject * obj0 = 0 ;
9506 PyObject * obj1 = 0 ;
9507 PyObject * obj2 = 0 ;
9508 char *kwnames[] = {
9509 (char *) "filename",(char *) "image",(char *) "type", NULL
9510 };
9511
9512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9513 {
9514 arg1 = wxString_in_helper(obj0);
9515 if (arg1 == NULL) SWIG_fail;
9516 temp1 = true;
9517 }
9518 {
9519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9520 if (SWIG_arg_fail(2)) SWIG_fail;
9521 if (arg2 == NULL) {
9522 SWIG_null_ref("wxImage");
9523 }
9524 if (SWIG_arg_fail(2)) SWIG_fail;
9525 }
9526 {
9527 arg3 = (long)(SWIG_As_long(obj2));
9528 if (SWIG_arg_fail(3)) SWIG_fail;
9529 }
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9533
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 Py_INCREF(Py_None); resultobj = Py_None;
9538 {
9539 if (temp1)
9540 delete arg1;
9541 }
9542 return resultobj;
9543 fail:
9544 {
9545 if (temp1)
9546 delete arg1;
9547 }
9548 return NULL;
9549 }
9550
9551
9552 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9553 PyObject *resultobj;
9554 wxString *arg1 = 0 ;
9555 wxBitmap *arg2 = 0 ;
9556 long arg3 ;
9557 bool temp1 = false ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 PyObject * obj2 = 0 ;
9561 char *kwnames[] = {
9562 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9563 };
9564
9565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9566 {
9567 arg1 = wxString_in_helper(obj0);
9568 if (arg1 == NULL) SWIG_fail;
9569 temp1 = true;
9570 }
9571 {
9572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9573 if (SWIG_arg_fail(2)) SWIG_fail;
9574 if (arg2 == NULL) {
9575 SWIG_null_ref("wxBitmap");
9576 }
9577 if (SWIG_arg_fail(2)) SWIG_fail;
9578 }
9579 {
9580 arg3 = (long)(SWIG_As_long(obj2));
9581 if (SWIG_arg_fail(3)) SWIG_fail;
9582 }
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 Py_INCREF(Py_None); resultobj = Py_None;
9591 {
9592 if (temp1)
9593 delete arg1;
9594 }
9595 return resultobj;
9596 fail:
9597 {
9598 if (temp1)
9599 delete arg1;
9600 }
9601 return NULL;
9602 }
9603
9604
9605 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj;
9607 wxString *arg1 = 0 ;
9608 PyObject *arg2 = (PyObject *) 0 ;
9609 bool temp1 = false ;
9610 PyObject * obj0 = 0 ;
9611 PyObject * obj1 = 0 ;
9612 char *kwnames[] = {
9613 (char *) "filename",(char *) "data", NULL
9614 };
9615
9616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9617 {
9618 arg1 = wxString_in_helper(obj0);
9619 if (arg1 == NULL) SWIG_fail;
9620 temp1 = true;
9621 }
9622 arg2 = obj1;
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 Py_INCREF(Py_None); resultobj = Py_None;
9631 {
9632 if (temp1)
9633 delete arg1;
9634 }
9635 return resultobj;
9636 fail:
9637 {
9638 if (temp1)
9639 delete arg1;
9640 }
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxMemoryFSHandler *result;
9648 char *kwnames[] = {
9649 NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj;
9669 wxString *arg1 = 0 ;
9670 bool temp1 = false ;
9671 PyObject * obj0 = 0 ;
9672 char *kwnames[] = {
9673 (char *) "filename", NULL
9674 };
9675
9676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9677 {
9678 arg1 = wxString_in_helper(obj0);
9679 if (arg1 == NULL) SWIG_fail;
9680 temp1 = true;
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 Py_INCREF(Py_None); resultobj = Py_None;
9690 {
9691 if (temp1)
9692 delete arg1;
9693 }
9694 return resultobj;
9695 fail:
9696 {
9697 if (temp1)
9698 delete arg1;
9699 }
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9707 wxString *arg2 = 0 ;
9708 bool result;
9709 bool temp2 = false ;
9710 PyObject * obj0 = 0 ;
9711 PyObject * obj1 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "self",(char *) "location", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(1)) SWIG_fail;
9719 {
9720 arg2 = wxString_in_helper(obj1);
9721 if (arg2 == NULL) SWIG_fail;
9722 temp2 = true;
9723 }
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9733 }
9734 {
9735 if (temp2)
9736 delete arg2;
9737 }
9738 return resultobj;
9739 fail:
9740 {
9741 if (temp2)
9742 delete arg2;
9743 }
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9751 wxFileSystem *arg2 = 0 ;
9752 wxString *arg3 = 0 ;
9753 wxFSFile *result;
9754 bool temp3 = false ;
9755 PyObject * obj0 = 0 ;
9756 PyObject * obj1 = 0 ;
9757 PyObject * obj2 = 0 ;
9758 char *kwnames[] = {
9759 (char *) "self",(char *) "fs",(char *) "location", NULL
9760 };
9761
9762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9764 if (SWIG_arg_fail(1)) SWIG_fail;
9765 {
9766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9767 if (SWIG_arg_fail(2)) SWIG_fail;
9768 if (arg2 == NULL) {
9769 SWIG_null_ref("wxFileSystem");
9770 }
9771 if (SWIG_arg_fail(2)) SWIG_fail;
9772 }
9773 {
9774 arg3 = wxString_in_helper(obj2);
9775 if (arg3 == NULL) SWIG_fail;
9776 temp3 = true;
9777 }
9778 {
9779 PyThreadState* __tstate = wxPyBeginAllowThreads();
9780 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9781
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 {
9786 resultobj = wxPyMake_wxObject(result, 1);
9787 }
9788 {
9789 if (temp3)
9790 delete arg3;
9791 }
9792 return resultobj;
9793 fail:
9794 {
9795 if (temp3)
9796 delete arg3;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9803 PyObject *resultobj;
9804 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9805 wxString *arg2 = 0 ;
9806 int arg3 = (int) 0 ;
9807 wxString result;
9808 bool temp2 = false ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char *kwnames[] = {
9813 (char *) "self",(char *) "spec",(char *) "flags", NULL
9814 };
9815
9816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9818 if (SWIG_arg_fail(1)) SWIG_fail;
9819 {
9820 arg2 = wxString_in_helper(obj1);
9821 if (arg2 == NULL) SWIG_fail;
9822 temp2 = true;
9823 }
9824 if (obj2) {
9825 {
9826 arg3 = (int)(SWIG_As_int(obj2));
9827 if (SWIG_arg_fail(3)) SWIG_fail;
9828 }
9829 }
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 {
9838 #if wxUSE_UNICODE
9839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9840 #else
9841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9842 #endif
9843 }
9844 {
9845 if (temp2)
9846 delete arg2;
9847 }
9848 return resultobj;
9849 fail:
9850 {
9851 if (temp2)
9852 delete arg2;
9853 }
9854 return NULL;
9855 }
9856
9857
9858 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj;
9860 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9861 wxString result;
9862 PyObject * obj0 = 0 ;
9863 char *kwnames[] = {
9864 (char *) "self", NULL
9865 };
9866
9867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9869 if (SWIG_arg_fail(1)) SWIG_fail;
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (arg1)->FindNext();
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 #if wxUSE_UNICODE
9879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9880 #else
9881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9882 #endif
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9891 PyObject *obj;
9892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9893 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9894 Py_INCREF(obj);
9895 return Py_BuildValue((char *)"");
9896 }
9897 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9900 wxString result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (arg1)->GetName();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (arg1)->GetExtension();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9964 long result;
9965 PyObject * obj0 = 0 ;
9966 char *kwnames[] = {
9967 (char *) "self", NULL
9968 };
9969
9970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9972 if (SWIG_arg_fail(1)) SWIG_fail;
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (long)(arg1)->GetType();
9976
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 {
9981 resultobj = SWIG_From_long((long)(result));
9982 }
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj;
9991 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9992 wxString result;
9993 PyObject * obj0 = 0 ;
9994 char *kwnames[] = {
9995 (char *) "self", NULL
9996 };
9997
9998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10000 if (SWIG_arg_fail(1)) SWIG_fail;
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (arg1)->GetMimeType();
10004
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 #if wxUSE_UNICODE
10010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10011 #else
10012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10013 #endif
10014 }
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10024 wxString *arg2 = 0 ;
10025 bool result;
10026 bool temp2 = false ;
10027 PyObject * obj0 = 0 ;
10028 PyObject * obj1 = 0 ;
10029 char *kwnames[] = {
10030 (char *) "self",(char *) "name", NULL
10031 };
10032
10033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10035 if (SWIG_arg_fail(1)) SWIG_fail;
10036 {
10037 arg2 = wxString_in_helper(obj1);
10038 if (arg2 == NULL) SWIG_fail;
10039 temp2 = true;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 {
10049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10050 }
10051 {
10052 if (temp2)
10053 delete arg2;
10054 }
10055 return resultobj;
10056 fail:
10057 {
10058 if (temp2)
10059 delete arg2;
10060 }
10061 return NULL;
10062 }
10063
10064
10065 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj;
10067 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10068 wxString *arg2 = 0 ;
10069 bool temp2 = false ;
10070 PyObject * obj0 = 0 ;
10071 PyObject * obj1 = 0 ;
10072 char *kwnames[] = {
10073 (char *) "self",(char *) "name", NULL
10074 };
10075
10076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10078 if (SWIG_arg_fail(1)) SWIG_fail;
10079 {
10080 arg2 = wxString_in_helper(obj1);
10081 if (arg2 == NULL) SWIG_fail;
10082 temp2 = true;
10083 }
10084 {
10085 PyThreadState* __tstate = wxPyBeginAllowThreads();
10086 (arg1)->SetName((wxString const &)*arg2);
10087
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 Py_INCREF(Py_None); resultobj = Py_None;
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 return resultobj;
10097 fail:
10098 {
10099 if (temp2)
10100 delete arg2;
10101 }
10102 return NULL;
10103 }
10104
10105
10106 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj;
10108 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10109 wxString *arg2 = 0 ;
10110 bool temp2 = false ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char *kwnames[] = {
10114 (char *) "self",(char *) "extension", NULL
10115 };
10116
10117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10119 if (SWIG_arg_fail(1)) SWIG_fail;
10120 {
10121 arg2 = wxString_in_helper(obj1);
10122 if (arg2 == NULL) SWIG_fail;
10123 temp2 = true;
10124 }
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 (arg1)->SetExtension((wxString const &)*arg2);
10128
10129 wxPyEndAllowThreads(__tstate);
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 Py_INCREF(Py_None); resultobj = Py_None;
10133 {
10134 if (temp2)
10135 delete arg2;
10136 }
10137 return resultobj;
10138 fail:
10139 {
10140 if (temp2)
10141 delete arg2;
10142 }
10143 return NULL;
10144 }
10145
10146
10147 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj;
10149 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10150 long arg2 ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 char *kwnames[] = {
10154 (char *) "self",(char *) "type", NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10159 if (SWIG_arg_fail(1)) SWIG_fail;
10160 {
10161 arg2 = (long)(SWIG_As_long(obj1));
10162 if (SWIG_arg_fail(2)) SWIG_fail;
10163 }
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 (arg1)->SetType(arg2);
10167
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 Py_INCREF(Py_None); resultobj = Py_None;
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10181 wxString *arg2 = 0 ;
10182 bool temp2 = false ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char *kwnames[] = {
10186 (char *) "self",(char *) "mimetype", NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 {
10193 arg2 = wxString_in_helper(obj1);
10194 if (arg2 == NULL) SWIG_fail;
10195 temp2 = true;
10196 }
10197 {
10198 PyThreadState* __tstate = wxPyBeginAllowThreads();
10199 (arg1)->SetMimeType((wxString const &)*arg2);
10200
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 Py_INCREF(Py_None); resultobj = Py_None;
10205 {
10206 if (temp2)
10207 delete arg2;
10208 }
10209 return resultobj;
10210 fail:
10211 {
10212 if (temp2)
10213 delete arg2;
10214 }
10215 return NULL;
10216 }
10217
10218
10219 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10220 PyObject *obj;
10221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10222 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10223 Py_INCREF(obj);
10224 return Py_BuildValue((char *)"");
10225 }
10226 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj;
10228 wxImageHistogram *result;
10229 char *kwnames[] = {
10230 NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 result = (wxImageHistogram *)new wxImageHistogram();
10237
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 byte arg1 ;
10251 byte arg2 ;
10252 byte arg3 ;
10253 unsigned long result;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 PyObject * obj2 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "r",(char *) "g",(char *) "b", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10262 {
10263 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10264 if (SWIG_arg_fail(1)) SWIG_fail;
10265 }
10266 {
10267 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10268 if (SWIG_arg_fail(2)) SWIG_fail;
10269 }
10270 {
10271 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10272 if (SWIG_arg_fail(3)) SWIG_fail;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10283 }
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj;
10292 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10293 byte *arg2 = (byte *) 0 ;
10294 byte *arg3 = (byte *) 0 ;
10295 byte *arg4 = (byte *) 0 ;
10296 byte arg5 = (byte) 1 ;
10297 byte arg6 = (byte) 0 ;
10298 byte arg7 = (byte) 0 ;
10299 bool result;
10300 byte temp2 ;
10301 int res2 = 0 ;
10302 byte temp3 ;
10303 int res3 = 0 ;
10304 byte temp4 ;
10305 int res4 = 0 ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 PyObject * obj2 = 0 ;
10309 PyObject * obj3 = 0 ;
10310 char *kwnames[] = {
10311 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10312 };
10313
10314 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10315 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10316 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10319 if (SWIG_arg_fail(1)) SWIG_fail;
10320 if (obj1) {
10321 {
10322 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10323 if (SWIG_arg_fail(5)) SWIG_fail;
10324 }
10325 }
10326 if (obj2) {
10327 {
10328 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10329 if (SWIG_arg_fail(6)) SWIG_fail;
10330 }
10331 }
10332 if (obj3) {
10333 {
10334 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10335 if (SWIG_arg_fail(7)) SWIG_fail;
10336 }
10337 }
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 {
10346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10347 }
10348 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10349 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10350 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10351 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10352 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10353 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10363 unsigned long arg2 ;
10364 unsigned long result;
10365 PyObject * obj0 = 0 ;
10366 PyObject * obj1 = 0 ;
10367 char *kwnames[] = {
10368 (char *) "self",(char *) "key", NULL
10369 };
10370
10371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10373 if (SWIG_arg_fail(1)) SWIG_fail;
10374 {
10375 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10376 if (SWIG_arg_fail(2)) SWIG_fail;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10387 }
10388 return resultobj;
10389 fail:
10390 return NULL;
10391 }
10392
10393
10394 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj;
10396 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10397 byte arg2 ;
10398 byte arg3 ;
10399 byte arg4 ;
10400 unsigned long result;
10401 PyObject * obj0 = 0 ;
10402 PyObject * obj1 = 0 ;
10403 PyObject * obj2 = 0 ;
10404 PyObject * obj3 = 0 ;
10405 char *kwnames[] = {
10406 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10411 if (SWIG_arg_fail(1)) SWIG_fail;
10412 {
10413 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10414 if (SWIG_arg_fail(2)) SWIG_fail;
10415 }
10416 {
10417 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10418 if (SWIG_arg_fail(3)) SWIG_fail;
10419 }
10420 {
10421 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10422 if (SWIG_arg_fail(4)) SWIG_fail;
10423 }
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10443 wxColour *arg2 = 0 ;
10444 unsigned long result;
10445 wxColour temp2 ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 char *kwnames[] = {
10449 (char *) "self",(char *) "colour", NULL
10450 };
10451
10452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10454 if (SWIG_arg_fail(1)) SWIG_fail;
10455 {
10456 arg2 = &temp2;
10457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10458 }
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10462
10463 wxPyEndAllowThreads(__tstate);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 {
10467 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10468 }
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10476 PyObject *obj;
10477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10478 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10479 Py_INCREF(obj);
10480 return Py_BuildValue((char *)"");
10481 }
10482 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10483 PyObject *resultobj;
10484 wxString *arg1 = 0 ;
10485 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10486 int arg3 = (int) -1 ;
10487 wxImage *result;
10488 bool temp1 = false ;
10489 PyObject * obj0 = 0 ;
10490 PyObject * obj1 = 0 ;
10491 PyObject * obj2 = 0 ;
10492 char *kwnames[] = {
10493 (char *) "name",(char *) "type",(char *) "index", NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10497 {
10498 arg1 = wxString_in_helper(obj0);
10499 if (arg1 == NULL) SWIG_fail;
10500 temp1 = true;
10501 }
10502 if (obj1) {
10503 {
10504 arg2 = (long)(SWIG_As_long(obj1));
10505 if (SWIG_arg_fail(2)) SWIG_fail;
10506 }
10507 }
10508 if (obj2) {
10509 {
10510 arg3 = (int)(SWIG_As_int(obj2));
10511 if (SWIG_arg_fail(3)) SWIG_fail;
10512 }
10513 }
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10522 {
10523 if (temp1)
10524 delete arg1;
10525 }
10526 return resultobj;
10527 fail:
10528 {
10529 if (temp1)
10530 delete arg1;
10531 }
10532 return NULL;
10533 }
10534
10535
10536 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10537 PyObject *resultobj;
10538 wxImage *arg1 = (wxImage *) 0 ;
10539 PyObject * obj0 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "self", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10546 if (SWIG_arg_fail(1)) SWIG_fail;
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 delete arg1;
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 Py_INCREF(Py_None); resultobj = Py_None;
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj;
10563 wxString *arg1 = 0 ;
10564 wxString *arg2 = 0 ;
10565 int arg3 = (int) -1 ;
10566 wxImage *result;
10567 bool temp1 = false ;
10568 bool temp2 = false ;
10569 PyObject * obj0 = 0 ;
10570 PyObject * obj1 = 0 ;
10571 PyObject * obj2 = 0 ;
10572 char *kwnames[] = {
10573 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10574 };
10575
10576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10577 {
10578 arg1 = wxString_in_helper(obj0);
10579 if (arg1 == NULL) SWIG_fail;
10580 temp1 = true;
10581 }
10582 {
10583 arg2 = wxString_in_helper(obj1);
10584 if (arg2 == NULL) SWIG_fail;
10585 temp2 = true;
10586 }
10587 if (obj2) {
10588 {
10589 arg3 = (int)(SWIG_As_int(obj2));
10590 if (SWIG_arg_fail(3)) SWIG_fail;
10591 }
10592 }
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return resultobj;
10610 fail:
10611 {
10612 if (temp1)
10613 delete arg1;
10614 }
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj;
10625 wxInputStream *arg1 = 0 ;
10626 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10627 int arg3 = (int) -1 ;
10628 wxImage *result;
10629 wxPyInputStream *temp1 ;
10630 bool created1 ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 PyObject * obj2 = 0 ;
10634 char *kwnames[] = {
10635 (char *) "stream",(char *) "type",(char *) "index", NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10639 {
10640 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10641 arg1 = temp1->m_wxis;
10642 created1 = false;
10643 } else {
10644 PyErr_Clear(); // clear the failure of the wxPyConvert above
10645 arg1 = wxPyCBInputStream_create(obj0, false);
10646 if (arg1 == NULL) {
10647 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10648 SWIG_fail;
10649 }
10650 created1 = true;
10651 }
10652 }
10653 if (obj1) {
10654 {
10655 arg2 = (long)(SWIG_As_long(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 }
10659 if (obj2) {
10660 {
10661 arg3 = (int)(SWIG_As_int(obj2));
10662 if (SWIG_arg_fail(3)) SWIG_fail;
10663 }
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10673 {
10674 if (created1) delete arg1;
10675 }
10676 return resultobj;
10677 fail:
10678 {
10679 if (created1) delete arg1;
10680 }
10681 return NULL;
10682 }
10683
10684
10685 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxInputStream *arg1 = 0 ;
10688 wxString *arg2 = 0 ;
10689 int arg3 = (int) -1 ;
10690 wxImage *result;
10691 wxPyInputStream *temp1 ;
10692 bool created1 ;
10693 bool temp2 = false ;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 PyObject * obj2 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10702 {
10703 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10704 arg1 = temp1->m_wxis;
10705 created1 = false;
10706 } else {
10707 PyErr_Clear(); // clear the failure of the wxPyConvert above
10708 arg1 = wxPyCBInputStream_create(obj0, false);
10709 if (arg1 == NULL) {
10710 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10711 SWIG_fail;
10712 }
10713 created1 = true;
10714 }
10715 }
10716 {
10717 arg2 = wxString_in_helper(obj1);
10718 if (arg2 == NULL) SWIG_fail;
10719 temp2 = true;
10720 }
10721 if (obj2) {
10722 {
10723 arg3 = (int)(SWIG_As_int(obj2));
10724 if (SWIG_arg_fail(3)) SWIG_fail;
10725 }
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10735 {
10736 if (created1) delete arg1;
10737 }
10738 {
10739 if (temp2)
10740 delete arg2;
10741 }
10742 return resultobj;
10743 fail:
10744 {
10745 if (created1) delete arg1;
10746 }
10747 {
10748 if (temp2)
10749 delete arg2;
10750 }
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 int arg1 = (int) 0 ;
10758 int arg2 = (int) 0 ;
10759 bool arg3 = (bool) true ;
10760 wxImage *result;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 PyObject * obj2 = 0 ;
10764 char *kwnames[] = {
10765 (char *) "width",(char *) "height",(char *) "clear", NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10769 if (obj0) {
10770 {
10771 arg1 = (int)(SWIG_As_int(obj0));
10772 if (SWIG_arg_fail(1)) SWIG_fail;
10773 }
10774 }
10775 if (obj1) {
10776 {
10777 arg2 = (int)(SWIG_As_int(obj1));
10778 if (SWIG_arg_fail(2)) SWIG_fail;
10779 }
10780 }
10781 if (obj2) {
10782 {
10783 arg3 = (bool)(SWIG_As_bool(obj2));
10784 if (SWIG_arg_fail(3)) SWIG_fail;
10785 }
10786 }
10787 {
10788 PyThreadState* __tstate = wxPyBeginAllowThreads();
10789 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10790
10791 wxPyEndAllowThreads(__tstate);
10792 if (PyErr_Occurred()) SWIG_fail;
10793 }
10794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj;
10803 wxBitmap *arg1 = 0 ;
10804 wxImage *result;
10805 PyObject * obj0 = 0 ;
10806 char *kwnames[] = {
10807 (char *) "bitmap", NULL
10808 };
10809
10810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10811 {
10812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 if (arg1 == NULL) {
10815 SWIG_null_ref("wxBitmap");
10816 }
10817 if (SWIG_arg_fail(1)) SWIG_fail;
10818 }
10819 {
10820 if (!wxPyCheckForApp()) SWIG_fail;
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10823
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 int arg1 ;
10837 int arg2 ;
10838 buffer arg3 ;
10839 int arg4 ;
10840 wxImage *result;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 PyObject * obj2 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "width",(char *) "height",(char *) "data", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10849 {
10850 arg1 = (int)(SWIG_As_int(obj0));
10851 if (SWIG_arg_fail(1)) SWIG_fail;
10852 }
10853 {
10854 arg2 = (int)(SWIG_As_int(obj1));
10855 if (SWIG_arg_fail(2)) SWIG_fail;
10856 }
10857 {
10858 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10863
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj;
10876 int arg1 ;
10877 int arg2 ;
10878 buffer arg3 ;
10879 int arg4 ;
10880 buffer arg5 ;
10881 int arg6 ;
10882 wxImage *result;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 PyObject * obj2 = 0 ;
10886 PyObject * obj3 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10892 {
10893 arg1 = (int)(SWIG_As_int(obj0));
10894 if (SWIG_arg_fail(1)) SWIG_fail;
10895 }
10896 {
10897 arg2 = (int)(SWIG_As_int(obj1));
10898 if (SWIG_arg_fail(2)) SWIG_fail;
10899 }
10900 {
10901 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10902 }
10903 {
10904 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10909
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10914 return resultobj;
10915 fail:
10916 return NULL;
10917 }
10918
10919
10920 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10921 PyObject *resultobj;
10922 wxImage *arg1 = (wxImage *) 0 ;
10923 int arg2 ;
10924 int arg3 ;
10925 bool arg4 = (bool) true ;
10926 PyObject * obj0 = 0 ;
10927 PyObject * obj1 = 0 ;
10928 PyObject * obj2 = 0 ;
10929 PyObject * obj3 = 0 ;
10930 char *kwnames[] = {
10931 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10932 };
10933
10934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10936 if (SWIG_arg_fail(1)) SWIG_fail;
10937 {
10938 arg2 = (int)(SWIG_As_int(obj1));
10939 if (SWIG_arg_fail(2)) SWIG_fail;
10940 }
10941 {
10942 arg3 = (int)(SWIG_As_int(obj2));
10943 if (SWIG_arg_fail(3)) SWIG_fail;
10944 }
10945 if (obj3) {
10946 {
10947 arg4 = (bool)(SWIG_As_bool(obj3));
10948 if (SWIG_arg_fail(4)) SWIG_fail;
10949 }
10950 }
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 (arg1)->Create(arg2,arg3,arg4);
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 Py_INCREF(Py_None); resultobj = Py_None;
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxImage *arg1 = (wxImage *) 0 ;
10968 PyObject * obj0 = 0 ;
10969 char *kwnames[] = {
10970 (char *) "self", NULL
10971 };
10972
10973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10975 if (SWIG_arg_fail(1)) SWIG_fail;
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 (arg1)->Destroy();
10979
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 Py_INCREF(Py_None); resultobj = Py_None;
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxImage *arg1 = (wxImage *) 0 ;
10993 int arg2 ;
10994 int arg3 ;
10995 SwigValueWrapper<wxImage > result;
10996 PyObject * obj0 = 0 ;
10997 PyObject * obj1 = 0 ;
10998 PyObject * obj2 = 0 ;
10999 char *kwnames[] = {
11000 (char *) "self",(char *) "width",(char *) "height", NULL
11001 };
11002
11003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11005 if (SWIG_arg_fail(1)) SWIG_fail;
11006 {
11007 arg2 = (int)(SWIG_As_int(obj1));
11008 if (SWIG_arg_fail(2)) SWIG_fail;
11009 }
11010 {
11011 arg3 = (int)(SWIG_As_int(obj2));
11012 if (SWIG_arg_fail(3)) SWIG_fail;
11013 }
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 result = (arg1)->Scale(arg2,arg3);
11017
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 {
11022 wxImage * resultptr;
11023 resultptr = new wxImage((wxImage &)(result));
11024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxImage *arg1 = (wxImage *) 0 ;
11035 int arg2 ;
11036 int arg3 ;
11037 SwigValueWrapper<wxImage > result;
11038 PyObject * obj0 = 0 ;
11039 PyObject * obj1 = 0 ;
11040 PyObject * obj2 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 {
11049 arg2 = (int)(SWIG_As_int(obj1));
11050 if (SWIG_arg_fail(2)) SWIG_fail;
11051 }
11052 {
11053 arg3 = (int)(SWIG_As_int(obj2));
11054 if (SWIG_arg_fail(3)) SWIG_fail;
11055 }
11056 {
11057 PyThreadState* __tstate = wxPyBeginAllowThreads();
11058 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11059
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 {
11064 wxImage * resultptr;
11065 resultptr = new wxImage((wxImage &)(result));
11066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11067 }
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj;
11076 wxImage *arg1 = (wxImage *) 0 ;
11077 int arg2 ;
11078 int arg3 ;
11079 wxImage *result;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 char *kwnames[] = {
11084 (char *) "self",(char *) "width",(char *) "height", NULL
11085 };
11086
11087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11089 if (SWIG_arg_fail(1)) SWIG_fail;
11090 {
11091 arg2 = (int)(SWIG_As_int(obj1));
11092 if (SWIG_arg_fail(2)) SWIG_fail;
11093 }
11094 {
11095 arg3 = (int)(SWIG_As_int(obj2));
11096 if (SWIG_arg_fail(3)) SWIG_fail;
11097 }
11098 {
11099 PyThreadState* __tstate = wxPyBeginAllowThreads();
11100 {
11101 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11102 result = (wxImage *) &_result_ref;
11103 }
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxImage *arg1 = (wxImage *) 0 ;
11118 wxSize *arg2 = 0 ;
11119 wxPoint *arg3 = 0 ;
11120 int arg4 = (int) -1 ;
11121 int arg5 = (int) -1 ;
11122 int arg6 = (int) -1 ;
11123 wxImage *result;
11124 wxSize temp2 ;
11125 wxPoint temp3 ;
11126 PyObject * obj0 = 0 ;
11127 PyObject * obj1 = 0 ;
11128 PyObject * obj2 = 0 ;
11129 PyObject * obj3 = 0 ;
11130 PyObject * obj4 = 0 ;
11131 PyObject * obj5 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11138 if (SWIG_arg_fail(1)) SWIG_fail;
11139 {
11140 arg2 = &temp2;
11141 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11142 }
11143 {
11144 arg3 = &temp3;
11145 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11146 }
11147 if (obj3) {
11148 {
11149 arg4 = (int)(SWIG_As_int(obj3));
11150 if (SWIG_arg_fail(4)) SWIG_fail;
11151 }
11152 }
11153 if (obj4) {
11154 {
11155 arg5 = (int)(SWIG_As_int(obj4));
11156 if (SWIG_arg_fail(5)) SWIG_fail;
11157 }
11158 }
11159 if (obj5) {
11160 {
11161 arg6 = (int)(SWIG_As_int(obj5));
11162 if (SWIG_arg_fail(6)) SWIG_fail;
11163 }
11164 }
11165 {
11166 PyThreadState* __tstate = wxPyBeginAllowThreads();
11167 {
11168 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11169 result = (wxImage *) &_result_ref;
11170 }
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11183 PyObject *resultobj;
11184 wxImage *arg1 = (wxImage *) 0 ;
11185 int arg2 ;
11186 int arg3 ;
11187 byte arg4 ;
11188 byte arg5 ;
11189 byte arg6 ;
11190 PyObject * obj0 = 0 ;
11191 PyObject * obj1 = 0 ;
11192 PyObject * obj2 = 0 ;
11193 PyObject * obj3 = 0 ;
11194 PyObject * obj4 = 0 ;
11195 PyObject * obj5 = 0 ;
11196 char *kwnames[] = {
11197 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11198 };
11199
11200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11202 if (SWIG_arg_fail(1)) SWIG_fail;
11203 {
11204 arg2 = (int)(SWIG_As_int(obj1));
11205 if (SWIG_arg_fail(2)) SWIG_fail;
11206 }
11207 {
11208 arg3 = (int)(SWIG_As_int(obj2));
11209 if (SWIG_arg_fail(3)) SWIG_fail;
11210 }
11211 {
11212 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11213 if (SWIG_arg_fail(4)) SWIG_fail;
11214 }
11215 {
11216 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11217 if (SWIG_arg_fail(5)) SWIG_fail;
11218 }
11219 {
11220 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11221 if (SWIG_arg_fail(6)) SWIG_fail;
11222 }
11223 {
11224 PyThreadState* __tstate = wxPyBeginAllowThreads();
11225 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11226
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 Py_INCREF(Py_None); resultobj = Py_None;
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj;
11239 wxImage *arg1 = (wxImage *) 0 ;
11240 wxRect *arg2 = 0 ;
11241 byte arg3 ;
11242 byte arg4 ;
11243 byte arg5 ;
11244 wxRect temp2 ;
11245 PyObject * obj0 = 0 ;
11246 PyObject * obj1 = 0 ;
11247 PyObject * obj2 = 0 ;
11248 PyObject * obj3 = 0 ;
11249 PyObject * obj4 = 0 ;
11250 char *kwnames[] = {
11251 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11252 };
11253
11254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11256 if (SWIG_arg_fail(1)) SWIG_fail;
11257 {
11258 arg2 = &temp2;
11259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11260 }
11261 {
11262 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11263 if (SWIG_arg_fail(3)) SWIG_fail;
11264 }
11265 {
11266 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11267 if (SWIG_arg_fail(4)) SWIG_fail;
11268 }
11269 {
11270 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11271 if (SWIG_arg_fail(5)) SWIG_fail;
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11276
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 Py_INCREF(Py_None); resultobj = Py_None;
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxImage *arg1 = (wxImage *) 0 ;
11290 int arg2 ;
11291 int arg3 ;
11292 byte result;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char *kwnames[] = {
11297 (char *) "self",(char *) "x",(char *) "y", NULL
11298 };
11299
11300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11302 if (SWIG_arg_fail(1)) SWIG_fail;
11303 {
11304 arg2 = (int)(SWIG_As_int(obj1));
11305 if (SWIG_arg_fail(2)) SWIG_fail;
11306 }
11307 {
11308 arg3 = (int)(SWIG_As_int(obj2));
11309 if (SWIG_arg_fail(3)) SWIG_fail;
11310 }
11311 {
11312 PyThreadState* __tstate = wxPyBeginAllowThreads();
11313 result = (byte)(arg1)->GetRed(arg2,arg3);
11314
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 {
11319 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11320 }
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj;
11329 wxImage *arg1 = (wxImage *) 0 ;
11330 int arg2 ;
11331 int arg3 ;
11332 byte result;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 char *kwnames[] = {
11337 (char *) "self",(char *) "x",(char *) "y", NULL
11338 };
11339
11340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11342 if (SWIG_arg_fail(1)) SWIG_fail;
11343 {
11344 arg2 = (int)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 {
11348 arg3 = (int)(SWIG_As_int(obj2));
11349 if (SWIG_arg_fail(3)) SWIG_fail;
11350 }
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = (byte)(arg1)->GetGreen(arg2,arg3);
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11360 }
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxImage *arg1 = (wxImage *) 0 ;
11370 int arg2 ;
11371 int arg3 ;
11372 byte result;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 char *kwnames[] = {
11377 (char *) "self",(char *) "x",(char *) "y", NULL
11378 };
11379
11380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11382 if (SWIG_arg_fail(1)) SWIG_fail;
11383 {
11384 arg2 = (int)(SWIG_As_int(obj1));
11385 if (SWIG_arg_fail(2)) SWIG_fail;
11386 }
11387 {
11388 arg3 = (int)(SWIG_As_int(obj2));
11389 if (SWIG_arg_fail(3)) SWIG_fail;
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = (byte)(arg1)->GetBlue(arg2,arg3);
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxImage *arg1 = (wxImage *) 0 ;
11410 int arg2 ;
11411 int arg3 ;
11412 byte arg4 ;
11413 PyObject * obj0 = 0 ;
11414 PyObject * obj1 = 0 ;
11415 PyObject * obj2 = 0 ;
11416 PyObject * obj3 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11423 if (SWIG_arg_fail(1)) SWIG_fail;
11424 {
11425 arg2 = (int)(SWIG_As_int(obj1));
11426 if (SWIG_arg_fail(2)) SWIG_fail;
11427 }
11428 {
11429 arg3 = (int)(SWIG_As_int(obj2));
11430 if (SWIG_arg_fail(3)) SWIG_fail;
11431 }
11432 {
11433 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11434 if (SWIG_arg_fail(4)) SWIG_fail;
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 (arg1)->SetAlpha(arg2,arg3,arg4);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxImage *arg1 = (wxImage *) 0 ;
11453 int arg2 ;
11454 int arg3 ;
11455 byte result;
11456 PyObject * obj0 = 0 ;
11457 PyObject * obj1 = 0 ;
11458 PyObject * obj2 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "self",(char *) "x",(char *) "y", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11465 if (SWIG_arg_fail(1)) SWIG_fail;
11466 {
11467 arg2 = (int)(SWIG_As_int(obj1));
11468 if (SWIG_arg_fail(2)) SWIG_fail;
11469 }
11470 {
11471 arg3 = (int)(SWIG_As_int(obj2));
11472 if (SWIG_arg_fail(3)) SWIG_fail;
11473 }
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11477
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 {
11482 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11483 }
11484 return resultobj;
11485 fail:
11486 return NULL;
11487 }
11488
11489
11490 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11491 PyObject *resultobj;
11492 wxImage *arg1 = (wxImage *) 0 ;
11493 bool result;
11494 PyObject * obj0 = 0 ;
11495 char *kwnames[] = {
11496 (char *) "self", NULL
11497 };
11498
11499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11501 if (SWIG_arg_fail(1)) SWIG_fail;
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (bool)(arg1)->HasAlpha();
11505
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 {
11510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 wxImage *arg1 = (wxImage *) 0 ;
11521 PyObject * obj0 = 0 ;
11522 char *kwnames[] = {
11523 (char *) "self", NULL
11524 };
11525
11526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11528 if (SWIG_arg_fail(1)) SWIG_fail;
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->InitAlpha();
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 Py_INCREF(Py_None); resultobj = Py_None;
11537 return resultobj;
11538 fail:
11539 return NULL;
11540 }
11541
11542
11543 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11544 PyObject *resultobj;
11545 wxImage *arg1 = (wxImage *) 0 ;
11546 int arg2 ;
11547 int arg3 ;
11548 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11549 bool result;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 PyObject * obj2 = 0 ;
11553 PyObject * obj3 = 0 ;
11554 char *kwnames[] = {
11555 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11556 };
11557
11558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11560 if (SWIG_arg_fail(1)) SWIG_fail;
11561 {
11562 arg2 = (int)(SWIG_As_int(obj1));
11563 if (SWIG_arg_fail(2)) SWIG_fail;
11564 }
11565 {
11566 arg3 = (int)(SWIG_As_int(obj2));
11567 if (SWIG_arg_fail(3)) SWIG_fail;
11568 }
11569 if (obj3) {
11570 {
11571 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11572 if (SWIG_arg_fail(4)) SWIG_fail;
11573 }
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11584 }
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj;
11593 wxImage *arg1 = (wxImage *) 0 ;
11594 byte *arg2 = (byte *) 0 ;
11595 byte *arg3 = (byte *) 0 ;
11596 byte *arg4 = (byte *) 0 ;
11597 byte arg5 = (byte) 0 ;
11598 byte arg6 = (byte) 0 ;
11599 byte arg7 = (byte) 0 ;
11600 bool result;
11601 byte temp2 ;
11602 int res2 = 0 ;
11603 byte temp3 ;
11604 int res3 = 0 ;
11605 byte temp4 ;
11606 int res4 = 0 ;
11607 PyObject * obj0 = 0 ;
11608 PyObject * obj1 = 0 ;
11609 PyObject * obj2 = 0 ;
11610 PyObject * obj3 = 0 ;
11611 char *kwnames[] = {
11612 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11613 };
11614
11615 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11616 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11617 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11620 if (SWIG_arg_fail(1)) SWIG_fail;
11621 if (obj1) {
11622 {
11623 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11624 if (SWIG_arg_fail(5)) SWIG_fail;
11625 }
11626 }
11627 if (obj2) {
11628 {
11629 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11630 if (SWIG_arg_fail(6)) SWIG_fail;
11631 }
11632 }
11633 if (obj3) {
11634 {
11635 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11636 if (SWIG_arg_fail(7)) SWIG_fail;
11637 }
11638 }
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11642
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 {
11647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11648 }
11649 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11650 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11651 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11652 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11653 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11654 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxImage *arg1 = (wxImage *) 0 ;
11664 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11665 bool result;
11666 PyObject * obj0 = 0 ;
11667 PyObject * obj1 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "threshold", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 if (obj1) {
11676 {
11677 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11678 if (SWIG_arg_fail(2)) SWIG_fail;
11679 }
11680 }
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11684
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 {
11689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11690 }
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj;
11699 wxImage *arg1 = (wxImage *) 0 ;
11700 byte arg2 ;
11701 byte arg3 ;
11702 byte arg4 ;
11703 bool result;
11704 PyObject * obj0 = 0 ;
11705 PyObject * obj1 = 0 ;
11706 PyObject * obj2 = 0 ;
11707 PyObject * obj3 = 0 ;
11708 char *kwnames[] = {
11709 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11710 };
11711
11712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 {
11716 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11717 if (SWIG_arg_fail(2)) SWIG_fail;
11718 }
11719 {
11720 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11721 if (SWIG_arg_fail(3)) SWIG_fail;
11722 }
11723 {
11724 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11725 if (SWIG_arg_fail(4)) SWIG_fail;
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11730
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11744 PyObject *resultobj;
11745 wxImage *arg1 = (wxImage *) 0 ;
11746 wxImage *arg2 = 0 ;
11747 byte arg3 ;
11748 byte arg4 ;
11749 byte arg5 ;
11750 bool result;
11751 PyObject * obj0 = 0 ;
11752 PyObject * obj1 = 0 ;
11753 PyObject * obj2 = 0 ;
11754 PyObject * obj3 = 0 ;
11755 PyObject * obj4 = 0 ;
11756 char *kwnames[] = {
11757 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11758 };
11759
11760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11762 if (SWIG_arg_fail(1)) SWIG_fail;
11763 {
11764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(2)) SWIG_fail;
11766 if (arg2 == NULL) {
11767 SWIG_null_ref("wxImage");
11768 }
11769 if (SWIG_arg_fail(2)) SWIG_fail;
11770 }
11771 {
11772 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11773 if (SWIG_arg_fail(3)) SWIG_fail;
11774 }
11775 {
11776 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11777 if (SWIG_arg_fail(4)) SWIG_fail;
11778 }
11779 {
11780 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11781 if (SWIG_arg_fail(5)) SWIG_fail;
11782 }
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11786
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxString *arg1 = 0 ;
11802 bool result;
11803 bool temp1 = false ;
11804 PyObject * obj0 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "filename", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11810 {
11811 arg1 = wxString_in_helper(obj0);
11812 if (arg1 == NULL) SWIG_fail;
11813 temp1 = true;
11814 }
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11824 }
11825 {
11826 if (temp1)
11827 delete arg1;
11828 }
11829 return resultobj;
11830 fail:
11831 {
11832 if (temp1)
11833 delete arg1;
11834 }
11835 return NULL;
11836 }
11837
11838
11839 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11840 PyObject *resultobj;
11841 wxString *arg1 = 0 ;
11842 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11843 int result;
11844 bool temp1 = false ;
11845 PyObject * obj0 = 0 ;
11846 PyObject * obj1 = 0 ;
11847 char *kwnames[] = {
11848 (char *) "filename",(char *) "type", NULL
11849 };
11850
11851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11852 {
11853 arg1 = wxString_in_helper(obj0);
11854 if (arg1 == NULL) SWIG_fail;
11855 temp1 = true;
11856 }
11857 if (obj1) {
11858 {
11859 arg2 = (long)(SWIG_As_long(obj1));
11860 if (SWIG_arg_fail(2)) SWIG_fail;
11861 }
11862 }
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11866
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = SWIG_From_int((int)(result));
11872 }
11873 {
11874 if (temp1)
11875 delete arg1;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxImage *arg1 = (wxImage *) 0 ;
11890 wxString *arg2 = 0 ;
11891 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11892 int arg4 = (int) -1 ;
11893 bool result;
11894 bool temp2 = false ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 PyObject * obj2 = 0 ;
11898 PyObject * obj3 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 arg2 = wxString_in_helper(obj1);
11908 if (arg2 == NULL) SWIG_fail;
11909 temp2 = true;
11910 }
11911 if (obj2) {
11912 {
11913 arg3 = (long)(SWIG_As_long(obj2));
11914 if (SWIG_arg_fail(3)) SWIG_fail;
11915 }
11916 }
11917 if (obj3) {
11918 {
11919 arg4 = (int)(SWIG_As_int(obj3));
11920 if (SWIG_arg_fail(4)) SWIG_fail;
11921 }
11922 }
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 {
11931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11932 }
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return resultobj;
11938 fail:
11939 {
11940 if (temp2)
11941 delete arg2;
11942 }
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxImage *arg1 = (wxImage *) 0 ;
11950 wxString *arg2 = 0 ;
11951 wxString *arg3 = 0 ;
11952 int arg4 = (int) -1 ;
11953 bool result;
11954 bool temp2 = false ;
11955 bool temp3 = false ;
11956 PyObject * obj0 = 0 ;
11957 PyObject * obj1 = 0 ;
11958 PyObject * obj2 = 0 ;
11959 PyObject * obj3 = 0 ;
11960 char *kwnames[] = {
11961 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11962 };
11963
11964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11966 if (SWIG_arg_fail(1)) SWIG_fail;
11967 {
11968 arg2 = wxString_in_helper(obj1);
11969 if (arg2 == NULL) SWIG_fail;
11970 temp2 = true;
11971 }
11972 {
11973 arg3 = wxString_in_helper(obj2);
11974 if (arg3 == NULL) SWIG_fail;
11975 temp3 = true;
11976 }
11977 if (obj3) {
11978 {
11979 arg4 = (int)(SWIG_As_int(obj3));
11980 if (SWIG_arg_fail(4)) SWIG_fail;
11981 }
11982 }
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11992 }
11993 {
11994 if (temp2)
11995 delete arg2;
11996 }
11997 {
11998 if (temp3)
11999 delete arg3;
12000 }
12001 return resultobj;
12002 fail:
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 {
12008 if (temp3)
12009 delete arg3;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxImage *arg1 = (wxImage *) 0 ;
12018 wxString *arg2 = 0 ;
12019 int arg3 ;
12020 bool result;
12021 bool temp2 = false ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 PyObject * obj2 = 0 ;
12025 char *kwnames[] = {
12026 (char *) "self",(char *) "name",(char *) "type", NULL
12027 };
12028
12029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12031 if (SWIG_arg_fail(1)) SWIG_fail;
12032 {
12033 arg2 = wxString_in_helper(obj1);
12034 if (arg2 == NULL) SWIG_fail;
12035 temp2 = true;
12036 }
12037 {
12038 arg3 = (int)(SWIG_As_int(obj2));
12039 if (SWIG_arg_fail(3)) SWIG_fail;
12040 }
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12050 }
12051 {
12052 if (temp2)
12053 delete arg2;
12054 }
12055 return resultobj;
12056 fail:
12057 {
12058 if (temp2)
12059 delete arg2;
12060 }
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj;
12067 wxImage *arg1 = (wxImage *) 0 ;
12068 wxString *arg2 = 0 ;
12069 wxString *arg3 = 0 ;
12070 bool result;
12071 bool temp2 = false ;
12072 bool temp3 = false ;
12073 PyObject * obj0 = 0 ;
12074 PyObject * obj1 = 0 ;
12075 PyObject * obj2 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 arg2 = wxString_in_helper(obj1);
12085 if (arg2 == NULL) SWIG_fail;
12086 temp2 = true;
12087 }
12088 {
12089 arg3 = wxString_in_helper(obj2);
12090 if (arg3 == NULL) SWIG_fail;
12091 temp3 = true;
12092 }
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12096
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 {
12101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12102 }
12103 {
12104 if (temp2)
12105 delete arg2;
12106 }
12107 {
12108 if (temp3)
12109 delete arg3;
12110 }
12111 return resultobj;
12112 fail:
12113 {
12114 if (temp2)
12115 delete arg2;
12116 }
12117 {
12118 if (temp3)
12119 delete arg3;
12120 }
12121 return NULL;
12122 }
12123
12124
12125 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj;
12127 wxInputStream *arg1 = 0 ;
12128 bool result;
12129 wxPyInputStream *temp1 ;
12130 bool created1 ;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "stream", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12137 {
12138 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12139 arg1 = temp1->m_wxis;
12140 created1 = false;
12141 } else {
12142 PyErr_Clear(); // clear the failure of the wxPyConvert above
12143 arg1 = wxPyCBInputStream_create(obj0, false);
12144 if (arg1 == NULL) {
12145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12146 SWIG_fail;
12147 }
12148 created1 = true;
12149 }
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (bool)wxImage::CanRead(*arg1);
12154
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 {
12159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12160 }
12161 {
12162 if (created1) delete arg1;
12163 }
12164 return resultobj;
12165 fail:
12166 {
12167 if (created1) delete arg1;
12168 }
12169 return NULL;
12170 }
12171
12172
12173 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12174 PyObject *resultobj;
12175 wxImage *arg1 = (wxImage *) 0 ;
12176 wxInputStream *arg2 = 0 ;
12177 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12178 int arg4 = (int) -1 ;
12179 bool result;
12180 wxPyInputStream *temp2 ;
12181 bool created2 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 PyObject * obj2 = 0 ;
12185 PyObject * obj3 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12195 arg2 = temp2->m_wxis;
12196 created2 = false;
12197 } else {
12198 PyErr_Clear(); // clear the failure of the wxPyConvert above
12199 arg2 = wxPyCBInputStream_create(obj1, false);
12200 if (arg2 == NULL) {
12201 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12202 SWIG_fail;
12203 }
12204 created2 = true;
12205 }
12206 }
12207 if (obj2) {
12208 {
12209 arg3 = (long)(SWIG_As_long(obj2));
12210 if (SWIG_arg_fail(3)) SWIG_fail;
12211 }
12212 }
12213 if (obj3) {
12214 {
12215 arg4 = (int)(SWIG_As_int(obj3));
12216 if (SWIG_arg_fail(4)) SWIG_fail;
12217 }
12218 }
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12222
12223 wxPyEndAllowThreads(__tstate);
12224 if (PyErr_Occurred()) SWIG_fail;
12225 }
12226 {
12227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12228 }
12229 {
12230 if (created2) delete arg2;
12231 }
12232 return resultobj;
12233 fail:
12234 {
12235 if (created2) delete arg2;
12236 }
12237 return NULL;
12238 }
12239
12240
12241 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj;
12243 wxImage *arg1 = (wxImage *) 0 ;
12244 wxInputStream *arg2 = 0 ;
12245 wxString *arg3 = 0 ;
12246 int arg4 = (int) -1 ;
12247 bool result;
12248 wxPyInputStream *temp2 ;
12249 bool created2 ;
12250 bool temp3 = false ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 PyObject * obj2 = 0 ;
12254 PyObject * obj3 = 0 ;
12255 char *kwnames[] = {
12256 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12257 };
12258
12259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12261 if (SWIG_arg_fail(1)) SWIG_fail;
12262 {
12263 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12264 arg2 = temp2->m_wxis;
12265 created2 = false;
12266 } else {
12267 PyErr_Clear(); // clear the failure of the wxPyConvert above
12268 arg2 = wxPyCBInputStream_create(obj1, false);
12269 if (arg2 == NULL) {
12270 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12271 SWIG_fail;
12272 }
12273 created2 = true;
12274 }
12275 }
12276 {
12277 arg3 = wxString_in_helper(obj2);
12278 if (arg3 == NULL) SWIG_fail;
12279 temp3 = true;
12280 }
12281 if (obj3) {
12282 {
12283 arg4 = (int)(SWIG_As_int(obj3));
12284 if (SWIG_arg_fail(4)) SWIG_fail;
12285 }
12286 }
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 {
12295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12296 }
12297 {
12298 if (created2) delete arg2;
12299 }
12300 {
12301 if (temp3)
12302 delete arg3;
12303 }
12304 return resultobj;
12305 fail:
12306 {
12307 if (created2) delete arg2;
12308 }
12309 {
12310 if (temp3)
12311 delete arg3;
12312 }
12313 return NULL;
12314 }
12315
12316
12317 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12318 PyObject *resultobj;
12319 wxImage *arg1 = (wxImage *) 0 ;
12320 bool result;
12321 PyObject * obj0 = 0 ;
12322 char *kwnames[] = {
12323 (char *) "self", NULL
12324 };
12325
12326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (bool)(arg1)->Ok();
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 {
12337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12338 }
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12346 PyObject *resultobj;
12347 wxImage *arg1 = (wxImage *) 0 ;
12348 int result;
12349 PyObject * obj0 = 0 ;
12350 char *kwnames[] = {
12351 (char *) "self", NULL
12352 };
12353
12354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12356 if (SWIG_arg_fail(1)) SWIG_fail;
12357 {
12358 PyThreadState* __tstate = wxPyBeginAllowThreads();
12359 result = (int)(arg1)->GetWidth();
12360
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 {
12365 resultobj = SWIG_From_int((int)(result));
12366 }
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj;
12375 wxImage *arg1 = (wxImage *) 0 ;
12376 int result;
12377 PyObject * obj0 = 0 ;
12378 char *kwnames[] = {
12379 (char *) "self", NULL
12380 };
12381
12382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12384 if (SWIG_arg_fail(1)) SWIG_fail;
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = (int)(arg1)->GetHeight();
12388
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 resultobj = SWIG_From_int((int)(result));
12394 }
12395 return resultobj;
12396 fail:
12397 return NULL;
12398 }
12399
12400
12401 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12402 PyObject *resultobj;
12403 wxImage *arg1 = (wxImage *) 0 ;
12404 wxSize result;
12405 PyObject * obj0 = 0 ;
12406 char *kwnames[] = {
12407 (char *) "self", NULL
12408 };
12409
12410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12412 if (SWIG_arg_fail(1)) SWIG_fail;
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 result = wxImage_GetSize(arg1);
12416
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 {
12421 wxSize * resultptr;
12422 resultptr = new wxSize((wxSize &)(result));
12423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12424 }
12425 return resultobj;
12426 fail:
12427 return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12432 PyObject *resultobj;
12433 wxImage *arg1 = (wxImage *) 0 ;
12434 wxRect *arg2 = 0 ;
12435 SwigValueWrapper<wxImage > result;
12436 wxRect temp2 ;
12437 PyObject * obj0 = 0 ;
12438 PyObject * obj1 = 0 ;
12439 char *kwnames[] = {
12440 (char *) "self",(char *) "rect", NULL
12441 };
12442
12443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12445 if (SWIG_arg_fail(1)) SWIG_fail;
12446 {
12447 arg2 = &temp2;
12448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12449 }
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12453
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 wxImage * resultptr;
12459 resultptr = new wxImage((wxImage &)(result));
12460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj;
12470 wxImage *arg1 = (wxImage *) 0 ;
12471 wxSize *arg2 = 0 ;
12472 wxPoint *arg3 = 0 ;
12473 int arg4 = (int) -1 ;
12474 int arg5 = (int) -1 ;
12475 int arg6 = (int) -1 ;
12476 SwigValueWrapper<wxImage > result;
12477 wxSize temp2 ;
12478 wxPoint temp3 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 PyObject * obj2 = 0 ;
12482 PyObject * obj3 = 0 ;
12483 PyObject * obj4 = 0 ;
12484 PyObject * obj5 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 arg2 = &temp2;
12494 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12495 }
12496 {
12497 arg3 = &temp3;
12498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12499 }
12500 if (obj3) {
12501 {
12502 arg4 = (int)(SWIG_As_int(obj3));
12503 if (SWIG_arg_fail(4)) SWIG_fail;
12504 }
12505 }
12506 if (obj4) {
12507 {
12508 arg5 = (int)(SWIG_As_int(obj4));
12509 if (SWIG_arg_fail(5)) SWIG_fail;
12510 }
12511 }
12512 if (obj5) {
12513 {
12514 arg6 = (int)(SWIG_As_int(obj5));
12515 if (SWIG_arg_fail(6)) SWIG_fail;
12516 }
12517 }
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 wxImage * resultptr;
12527 resultptr = new wxImage((wxImage &)(result));
12528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj;
12538 wxImage *arg1 = (wxImage *) 0 ;
12539 SwigValueWrapper<wxImage > result;
12540 PyObject * obj0 = 0 ;
12541 char *kwnames[] = {
12542 (char *) "self", NULL
12543 };
12544
12545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12547 if (SWIG_arg_fail(1)) SWIG_fail;
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 result = (arg1)->Copy();
12551
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 {
12556 wxImage * resultptr;
12557 resultptr = new wxImage((wxImage &)(result));
12558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12559 }
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj;
12568 wxImage *arg1 = (wxImage *) 0 ;
12569 wxImage *arg2 = 0 ;
12570 int arg3 ;
12571 int arg4 ;
12572 PyObject * obj0 = 0 ;
12573 PyObject * obj1 = 0 ;
12574 PyObject * obj2 = 0 ;
12575 PyObject * obj3 = 0 ;
12576 char *kwnames[] = {
12577 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12578 };
12579
12580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12582 if (SWIG_arg_fail(1)) SWIG_fail;
12583 {
12584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(2)) SWIG_fail;
12586 if (arg2 == NULL) {
12587 SWIG_null_ref("wxImage");
12588 }
12589 if (SWIG_arg_fail(2)) SWIG_fail;
12590 }
12591 {
12592 arg3 = (int)(SWIG_As_int(obj2));
12593 if (SWIG_arg_fail(3)) SWIG_fail;
12594 }
12595 {
12596 arg4 = (int)(SWIG_As_int(obj3));
12597 if (SWIG_arg_fail(4)) SWIG_fail;
12598 }
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12602
12603 wxPyEndAllowThreads(__tstate);
12604 if (PyErr_Occurred()) SWIG_fail;
12605 }
12606 Py_INCREF(Py_None); resultobj = Py_None;
12607 return resultobj;
12608 fail:
12609 return NULL;
12610 }
12611
12612
12613 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12614 PyObject *resultobj;
12615 wxImage *arg1 = (wxImage *) 0 ;
12616 PyObject *result;
12617 PyObject * obj0 = 0 ;
12618 char *kwnames[] = {
12619 (char *) "self", NULL
12620 };
12621
12622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(1)) SWIG_fail;
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 result = (PyObject *)wxImage_GetData(arg1);
12628
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = result;
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj;
12641 wxImage *arg1 = (wxImage *) 0 ;
12642 buffer arg2 ;
12643 int arg3 ;
12644 PyObject * obj0 = 0 ;
12645 PyObject * obj1 = 0 ;
12646 char *kwnames[] = {
12647 (char *) "self",(char *) "data", NULL
12648 };
12649
12650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12652 if (SWIG_arg_fail(1)) SWIG_fail;
12653 {
12654 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12655 }
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 wxImage_SetData(arg1,arg2,arg3);
12659
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 Py_INCREF(Py_None); resultobj = Py_None;
12664 return resultobj;
12665 fail:
12666 return NULL;
12667 }
12668
12669
12670 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12671 PyObject *resultobj;
12672 wxImage *arg1 = (wxImage *) 0 ;
12673 PyObject *result;
12674 PyObject * obj0 = 0 ;
12675 char *kwnames[] = {
12676 (char *) "self", NULL
12677 };
12678
12679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12681 if (SWIG_arg_fail(1)) SWIG_fail;
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 resultobj = result;
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxImage *arg1 = (wxImage *) 0 ;
12699 buffer arg2 ;
12700 int arg3 ;
12701 PyObject * obj0 = 0 ;
12702 PyObject * obj1 = 0 ;
12703 char *kwnames[] = {
12704 (char *) "self",(char *) "data", NULL
12705 };
12706
12707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(1)) SWIG_fail;
12710 {
12711 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12712 }
12713 {
12714 PyThreadState* __tstate = wxPyBeginAllowThreads();
12715 wxImage_SetDataBuffer(arg1,arg2,arg3);
12716
12717 wxPyEndAllowThreads(__tstate);
12718 if (PyErr_Occurred()) SWIG_fail;
12719 }
12720 Py_INCREF(Py_None); resultobj = Py_None;
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj;
12729 wxImage *arg1 = (wxImage *) 0 ;
12730 PyObject *result;
12731 PyObject * obj0 = 0 ;
12732 char *kwnames[] = {
12733 (char *) "self", NULL
12734 };
12735
12736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12738 if (SWIG_arg_fail(1)) SWIG_fail;
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 result = (PyObject *)wxImage_GetAlphaData(arg1);
12742
12743 wxPyEndAllowThreads(__tstate);
12744 if (PyErr_Occurred()) SWIG_fail;
12745 }
12746 resultobj = result;
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12754 PyObject *resultobj;
12755 wxImage *arg1 = (wxImage *) 0 ;
12756 buffer arg2 ;
12757 int arg3 ;
12758 PyObject * obj0 = 0 ;
12759 PyObject * obj1 = 0 ;
12760 char *kwnames[] = {
12761 (char *) "self",(char *) "alpha", NULL
12762 };
12763
12764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(1)) SWIG_fail;
12767 {
12768 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12769 }
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 wxImage_SetAlphaData(arg1,arg2,arg3);
12773
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 Py_INCREF(Py_None); resultobj = Py_None;
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj;
12786 wxImage *arg1 = (wxImage *) 0 ;
12787 PyObject *result;
12788 PyObject * obj0 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 resultobj = result;
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12811 PyObject *resultobj;
12812 wxImage *arg1 = (wxImage *) 0 ;
12813 buffer arg2 ;
12814 int arg3 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self",(char *) "alpha", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 Py_INCREF(Py_None); resultobj = Py_None;
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxImage *arg1 = (wxImage *) 0 ;
12844 byte arg2 ;
12845 byte arg3 ;
12846 byte arg4 ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 PyObject * obj3 = 0 ;
12851 char *kwnames[] = {
12852 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12853 };
12854
12855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12857 if (SWIG_arg_fail(1)) SWIG_fail;
12858 {
12859 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12860 if (SWIG_arg_fail(2)) SWIG_fail;
12861 }
12862 {
12863 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12864 if (SWIG_arg_fail(3)) SWIG_fail;
12865 }
12866 {
12867 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12868 if (SWIG_arg_fail(4)) SWIG_fail;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 (arg1)->SetMaskColour(arg2,arg3,arg4);
12873
12874 wxPyEndAllowThreads(__tstate);
12875 if (PyErr_Occurred()) SWIG_fail;
12876 }
12877 Py_INCREF(Py_None); resultobj = Py_None;
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12885 PyObject *resultobj;
12886 wxImage *arg1 = (wxImage *) 0 ;
12887 byte *arg2 = (byte *) 0 ;
12888 byte *arg3 = (byte *) 0 ;
12889 byte *arg4 = (byte *) 0 ;
12890 byte temp2 ;
12891 int res2 = 0 ;
12892 byte temp3 ;
12893 int res3 = 0 ;
12894 byte temp4 ;
12895 int res4 = 0 ;
12896 PyObject * obj0 = 0 ;
12897 char *kwnames[] = {
12898 (char *) "self", NULL
12899 };
12900
12901 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12902 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12903 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12906 if (SWIG_arg_fail(1)) SWIG_fail;
12907 {
12908 PyThreadState* __tstate = wxPyBeginAllowThreads();
12909 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12910
12911 wxPyEndAllowThreads(__tstate);
12912 if (PyErr_Occurred()) SWIG_fail;
12913 }
12914 Py_INCREF(Py_None); resultobj = Py_None;
12915 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12916 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12917 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12918 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12919 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12920 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxImage *arg1 = (wxImage *) 0 ;
12930 byte result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (byte)(arg1)->GetMaskRed();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxImage *arg1 = (wxImage *) 0 ;
12958 byte result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (byte)(arg1)->GetMaskGreen();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxImage *arg1 = (wxImage *) 0 ;
12986 byte result;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (byte)(arg1)->GetMaskBlue();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 {
13003 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13004 }
13005 return resultobj;
13006 fail:
13007 return NULL;
13008 }
13009
13010
13011 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13012 PyObject *resultobj;
13013 wxImage *arg1 = (wxImage *) 0 ;
13014 bool arg2 = (bool) true ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self",(char *) "mask", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13023 if (SWIG_arg_fail(1)) SWIG_fail;
13024 if (obj1) {
13025 {
13026 arg2 = (bool)(SWIG_As_bool(obj1));
13027 if (SWIG_arg_fail(2)) SWIG_fail;
13028 }
13029 }
13030 {
13031 PyThreadState* __tstate = wxPyBeginAllowThreads();
13032 (arg1)->SetMask(arg2);
13033
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 Py_INCREF(Py_None); resultobj = Py_None;
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13045 PyObject *resultobj;
13046 wxImage *arg1 = (wxImage *) 0 ;
13047 bool result;
13048 PyObject * obj0 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 result = (bool)(arg1)->HasMask();
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 {
13064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13065 }
13066 return resultobj;
13067 fail:
13068 return NULL;
13069 }
13070
13071
13072 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj;
13074 wxImage *arg1 = (wxImage *) 0 ;
13075 double arg2 ;
13076 wxPoint *arg3 = 0 ;
13077 bool arg4 = (bool) true ;
13078 wxPoint *arg5 = (wxPoint *) NULL ;
13079 SwigValueWrapper<wxImage > result;
13080 wxPoint temp3 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 PyObject * obj2 = 0 ;
13084 PyObject * obj3 = 0 ;
13085 PyObject * obj4 = 0 ;
13086 char *kwnames[] = {
13087 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13088 };
13089
13090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(1)) SWIG_fail;
13093 {
13094 arg2 = (double)(SWIG_As_double(obj1));
13095 if (SWIG_arg_fail(2)) SWIG_fail;
13096 }
13097 {
13098 arg3 = &temp3;
13099 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13100 }
13101 if (obj3) {
13102 {
13103 arg4 = (bool)(SWIG_As_bool(obj3));
13104 if (SWIG_arg_fail(4)) SWIG_fail;
13105 }
13106 }
13107 if (obj4) {
13108 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(5)) SWIG_fail;
13110 }
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 wxImage * resultptr;
13120 resultptr = new wxImage((wxImage &)(result));
13121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13122 }
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj;
13131 wxImage *arg1 = (wxImage *) 0 ;
13132 bool arg2 = (bool) true ;
13133 SwigValueWrapper<wxImage > result;
13134 PyObject * obj0 = 0 ;
13135 PyObject * obj1 = 0 ;
13136 char *kwnames[] = {
13137 (char *) "self",(char *) "clockwise", NULL
13138 };
13139
13140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13142 if (SWIG_arg_fail(1)) SWIG_fail;
13143 if (obj1) {
13144 {
13145 arg2 = (bool)(SWIG_As_bool(obj1));
13146 if (SWIG_arg_fail(2)) SWIG_fail;
13147 }
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (arg1)->Rotate90(arg2);
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 {
13157 wxImage * resultptr;
13158 resultptr = new wxImage((wxImage &)(result));
13159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxImage *arg1 = (wxImage *) 0 ;
13170 bool arg2 = (bool) true ;
13171 SwigValueWrapper<wxImage > result;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 char *kwnames[] = {
13175 (char *) "self",(char *) "horizontally", NULL
13176 };
13177
13178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13180 if (SWIG_arg_fail(1)) SWIG_fail;
13181 if (obj1) {
13182 {
13183 arg2 = (bool)(SWIG_As_bool(obj1));
13184 if (SWIG_arg_fail(2)) SWIG_fail;
13185 }
13186 }
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 result = (arg1)->Mirror(arg2);
13190
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 wxImage * resultptr;
13196 resultptr = new wxImage((wxImage &)(result));
13197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13198 }
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj;
13207 wxImage *arg1 = (wxImage *) 0 ;
13208 byte arg2 ;
13209 byte arg3 ;
13210 byte arg4 ;
13211 byte arg5 ;
13212 byte arg6 ;
13213 byte arg7 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 PyObject * obj2 = 0 ;
13217 PyObject * obj3 = 0 ;
13218 PyObject * obj4 = 0 ;
13219 PyObject * obj5 = 0 ;
13220 PyObject * obj6 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13230 if (SWIG_arg_fail(2)) SWIG_fail;
13231 }
13232 {
13233 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13234 if (SWIG_arg_fail(3)) SWIG_fail;
13235 }
13236 {
13237 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13238 if (SWIG_arg_fail(4)) SWIG_fail;
13239 }
13240 {
13241 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13242 if (SWIG_arg_fail(5)) SWIG_fail;
13243 }
13244 {
13245 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13246 if (SWIG_arg_fail(6)) SWIG_fail;
13247 }
13248 {
13249 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13250 if (SWIG_arg_fail(7)) SWIG_fail;
13251 }
13252 {
13253 PyThreadState* __tstate = wxPyBeginAllowThreads();
13254 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13255
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 Py_INCREF(Py_None); resultobj = Py_None;
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj;
13268 wxImage *arg1 = (wxImage *) 0 ;
13269 byte arg2 ;
13270 byte arg3 ;
13271 byte arg4 ;
13272 SwigValueWrapper<wxImage > result;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 PyObject * obj2 = 0 ;
13276 PyObject * obj3 = 0 ;
13277 char *kwnames[] = {
13278 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13279 };
13280
13281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13283 if (SWIG_arg_fail(1)) SWIG_fail;
13284 {
13285 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13286 if (SWIG_arg_fail(2)) SWIG_fail;
13287 }
13288 {
13289 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13290 if (SWIG_arg_fail(3)) SWIG_fail;
13291 }
13292 {
13293 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13294 if (SWIG_arg_fail(4)) SWIG_fail;
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 {
13304 wxImage * resultptr;
13305 resultptr = new wxImage((wxImage &)(result));
13306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13307 }
13308 return resultobj;
13309 fail:
13310 return NULL;
13311 }
13312
13313
13314 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj;
13316 wxImage *arg1 = (wxImage *) 0 ;
13317 wxString *arg2 = 0 ;
13318 wxString *arg3 = 0 ;
13319 bool temp2 = false ;
13320 bool temp3 = false ;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 PyObject * obj2 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self",(char *) "name",(char *) "value", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 {
13332 arg2 = wxString_in_helper(obj1);
13333 if (arg2 == NULL) SWIG_fail;
13334 temp2 = true;
13335 }
13336 {
13337 arg3 = wxString_in_helper(obj2);
13338 if (arg3 == NULL) SWIG_fail;
13339 temp3 = true;
13340 }
13341 {
13342 PyThreadState* __tstate = wxPyBeginAllowThreads();
13343 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13344
13345 wxPyEndAllowThreads(__tstate);
13346 if (PyErr_Occurred()) SWIG_fail;
13347 }
13348 Py_INCREF(Py_None); resultobj = Py_None;
13349 {
13350 if (temp2)
13351 delete arg2;
13352 }
13353 {
13354 if (temp3)
13355 delete arg3;
13356 }
13357 return resultobj;
13358 fail:
13359 {
13360 if (temp2)
13361 delete arg2;
13362 }
13363 {
13364 if (temp3)
13365 delete arg3;
13366 }
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 wxImage *arg1 = (wxImage *) 0 ;
13374 wxString *arg2 = 0 ;
13375 int arg3 ;
13376 bool temp2 = false ;
13377 PyObject * obj0 = 0 ;
13378 PyObject * obj1 = 0 ;
13379 PyObject * obj2 = 0 ;
13380 char *kwnames[] = {
13381 (char *) "self",(char *) "name",(char *) "value", NULL
13382 };
13383
13384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13386 if (SWIG_arg_fail(1)) SWIG_fail;
13387 {
13388 arg2 = wxString_in_helper(obj1);
13389 if (arg2 == NULL) SWIG_fail;
13390 temp2 = true;
13391 }
13392 {
13393 arg3 = (int)(SWIG_As_int(obj2));
13394 if (SWIG_arg_fail(3)) SWIG_fail;
13395 }
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 (arg1)->SetOption((wxString const &)*arg2,arg3);
13399
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 Py_INCREF(Py_None); resultobj = Py_None;
13404 {
13405 if (temp2)
13406 delete arg2;
13407 }
13408 return resultobj;
13409 fail:
13410 {
13411 if (temp2)
13412 delete arg2;
13413 }
13414 return NULL;
13415 }
13416
13417
13418 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj;
13420 wxImage *arg1 = (wxImage *) 0 ;
13421 wxString *arg2 = 0 ;
13422 wxString result;
13423 bool temp2 = false ;
13424 PyObject * obj0 = 0 ;
13425 PyObject * obj1 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "self",(char *) "name", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) 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 = wxString_in_helper(obj1);
13435 if (arg2 == NULL) SWIG_fail;
13436 temp2 = true;
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 {
13446 #if wxUSE_UNICODE
13447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13448 #else
13449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13450 #endif
13451 }
13452 {
13453 if (temp2)
13454 delete arg2;
13455 }
13456 return resultobj;
13457 fail:
13458 {
13459 if (temp2)
13460 delete arg2;
13461 }
13462 return NULL;
13463 }
13464
13465
13466 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj;
13468 wxImage *arg1 = (wxImage *) 0 ;
13469 wxString *arg2 = 0 ;
13470 int result;
13471 bool temp2 = false ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char *kwnames[] = {
13475 (char *) "self",(char *) "name", NULL
13476 };
13477
13478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13480 if (SWIG_arg_fail(1)) SWIG_fail;
13481 {
13482 arg2 = wxString_in_helper(obj1);
13483 if (arg2 == NULL) SWIG_fail;
13484 temp2 = true;
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13489
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 {
13494 resultobj = SWIG_From_int((int)(result));
13495 }
13496 {
13497 if (temp2)
13498 delete arg2;
13499 }
13500 return resultobj;
13501 fail:
13502 {
13503 if (temp2)
13504 delete arg2;
13505 }
13506 return NULL;
13507 }
13508
13509
13510 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 wxString *arg2 = 0 ;
13514 bool result;
13515 bool temp2 = false ;
13516 PyObject * obj0 = 0 ;
13517 PyObject * obj1 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self",(char *) "name", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 {
13538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13539 }
13540 {
13541 if (temp2)
13542 delete arg2;
13543 }
13544 return resultobj;
13545 fail:
13546 {
13547 if (temp2)
13548 delete arg2;
13549 }
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxImage *arg1 = (wxImage *) 0 ;
13557 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13558 unsigned long result;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self",(char *) "stopafter", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 if (obj1) {
13569 {
13570 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13571 if (SWIG_arg_fail(2)) SWIG_fail;
13572 }
13573 }
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (unsigned long)(arg1)->CountColours(arg2);
13577
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 {
13582 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13583 }
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13591 PyObject *resultobj;
13592 wxImage *arg1 = (wxImage *) 0 ;
13593 wxImageHistogram *arg2 = 0 ;
13594 unsigned long result;
13595 PyObject * obj0 = 0 ;
13596 PyObject * obj1 = 0 ;
13597 char *kwnames[] = {
13598 (char *) "self",(char *) "h", NULL
13599 };
13600
13601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13603 if (SWIG_arg_fail(1)) SWIG_fail;
13604 {
13605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13606 if (SWIG_arg_fail(2)) SWIG_fail;
13607 if (arg2 == NULL) {
13608 SWIG_null_ref("wxImageHistogram");
13609 }
13610 if (SWIG_arg_fail(2)) SWIG_fail;
13611 }
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13615
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 {
13620 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13621 }
13622 return resultobj;
13623 fail:
13624 return NULL;
13625 }
13626
13627
13628 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13631 PyObject * obj0 = 0 ;
13632 char *kwnames[] = {
13633 (char *) "handler", NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(1)) SWIG_fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 wxImage::AddHandler(arg1);
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 Py_INCREF(Py_None); resultobj = Py_None;
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13656 PyObject * obj0 = 0 ;
13657 char *kwnames[] = {
13658 (char *) "handler", NULL
13659 };
13660
13661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13663 if (SWIG_arg_fail(1)) SWIG_fail;
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 wxImage::InsertHandler(arg1);
13667
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 Py_INCREF(Py_None); resultobj = Py_None;
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj;
13680 wxString *arg1 = 0 ;
13681 bool result;
13682 bool temp1 = false ;
13683 PyObject * obj0 = 0 ;
13684 char *kwnames[] = {
13685 (char *) "name", NULL
13686 };
13687
13688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13689 {
13690 arg1 = wxString_in_helper(obj0);
13691 if (arg1 == NULL) SWIG_fail;
13692 temp1 = true;
13693 }
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13697
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 {
13702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13703 }
13704 {
13705 if (temp1)
13706 delete arg1;
13707 }
13708 return resultobj;
13709 fail:
13710 {
13711 if (temp1)
13712 delete arg1;
13713 }
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxString result;
13721 char *kwnames[] = {
13722 NULL
13723 };
13724
13725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13726 {
13727 PyThreadState* __tstate = wxPyBeginAllowThreads();
13728 result = wxImage::GetImageExtWildcard();
13729
13730 wxPyEndAllowThreads(__tstate);
13731 if (PyErr_Occurred()) SWIG_fail;
13732 }
13733 {
13734 #if wxUSE_UNICODE
13735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13736 #else
13737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13738 #endif
13739 }
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxImage *arg1 = (wxImage *) 0 ;
13749 int arg2 = (int) -1 ;
13750 wxBitmap result;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 char *kwnames[] = {
13754 (char *) "self",(char *) "depth", NULL
13755 };
13756
13757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13759 if (SWIG_arg_fail(1)) SWIG_fail;
13760 if (obj1) {
13761 {
13762 arg2 = (int)(SWIG_As_int(obj1));
13763 if (SWIG_arg_fail(2)) SWIG_fail;
13764 }
13765 }
13766 {
13767 if (!wxPyCheckForApp()) SWIG_fail;
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = wxImage_ConvertToBitmap(arg1,arg2);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 {
13775 wxBitmap * resultptr;
13776 resultptr = new wxBitmap((wxBitmap &)(result));
13777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13778 }
13779 return resultobj;
13780 fail:
13781 return NULL;
13782 }
13783
13784
13785 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj;
13787 wxImage *arg1 = (wxImage *) 0 ;
13788 byte arg2 ;
13789 byte arg3 ;
13790 byte arg4 ;
13791 wxBitmap result;
13792 PyObject * obj0 = 0 ;
13793 PyObject * obj1 = 0 ;
13794 PyObject * obj2 = 0 ;
13795 PyObject * obj3 = 0 ;
13796 char *kwnames[] = {
13797 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13798 };
13799
13800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13805 if (SWIG_arg_fail(2)) SWIG_fail;
13806 }
13807 {
13808 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13809 if (SWIG_arg_fail(3)) SWIG_fail;
13810 }
13811 {
13812 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13813 if (SWIG_arg_fail(4)) SWIG_fail;
13814 }
13815 {
13816 if (!wxPyCheckForApp()) SWIG_fail;
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 {
13824 wxBitmap * resultptr;
13825 resultptr = new wxBitmap((wxBitmap &)(result));
13826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13827 }
13828 return resultobj;
13829 fail:
13830 return NULL;
13831 }
13832
13833
13834 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13835 PyObject *obj;
13836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13837 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13838 Py_INCREF(obj);
13839 return Py_BuildValue((char *)"");
13840 }
13841 static int _wrap_NullImage_set(PyObject *) {
13842 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13843 return 1;
13844 }
13845
13846
13847 static PyObject *_wrap_NullImage_get(void) {
13848 PyObject *pyobj;
13849
13850 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13851 return pyobj;
13852 }
13853
13854
13855 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13856 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13857 return 1;
13858 }
13859
13860
13861 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13862 PyObject *pyobj;
13863
13864 {
13865 #if wxUSE_UNICODE
13866 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13867 #else
13868 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13869 #endif
13870 }
13871 return pyobj;
13872 }
13873
13874
13875 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13876 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13877 return 1;
13878 }
13879
13880
13881 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13882 PyObject *pyobj;
13883
13884 {
13885 #if wxUSE_UNICODE
13886 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13887 #else
13888 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13889 #endif
13890 }
13891 return pyobj;
13892 }
13893
13894
13895 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13896 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13897 return 1;
13898 }
13899
13900
13901 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13902 PyObject *pyobj;
13903
13904 {
13905 #if wxUSE_UNICODE
13906 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13907 #else
13908 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13909 #endif
13910 }
13911 return pyobj;
13912 }
13913
13914
13915 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13916 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13917 return 1;
13918 }
13919
13920
13921 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13922 PyObject *pyobj;
13923
13924 {
13925 #if wxUSE_UNICODE
13926 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13927 #else
13928 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13929 #endif
13930 }
13931 return pyobj;
13932 }
13933
13934
13935 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13936 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13937 return 1;
13938 }
13939
13940
13941 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13942 PyObject *pyobj;
13943
13944 {
13945 #if wxUSE_UNICODE
13946 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13947 #else
13948 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13949 #endif
13950 }
13951 return pyobj;
13952 }
13953
13954
13955 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13956 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13957 return 1;
13958 }
13959
13960
13961 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13962 PyObject *pyobj;
13963
13964 {
13965 #if wxUSE_UNICODE
13966 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13967 #else
13968 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13969 #endif
13970 }
13971 return pyobj;
13972 }
13973
13974
13975 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13976 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13977 return 1;
13978 }
13979
13980
13981 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13982 PyObject *pyobj;
13983
13984 {
13985 #if wxUSE_UNICODE
13986 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13987 #else
13988 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13989 #endif
13990 }
13991 return pyobj;
13992 }
13993
13994
13995 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13996 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13997 return 1;
13998 }
13999
14000
14001 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14002 PyObject *pyobj;
14003
14004 {
14005 #if wxUSE_UNICODE
14006 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14007 #else
14008 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14009 #endif
14010 }
14011 return pyobj;
14012 }
14013
14014
14015 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14016 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14017 return 1;
14018 }
14019
14020
14021 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14022 PyObject *pyobj;
14023
14024 {
14025 #if wxUSE_UNICODE
14026 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14027 #else
14028 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14029 #endif
14030 }
14031 return pyobj;
14032 }
14033
14034
14035 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14036 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14037 return 1;
14038 }
14039
14040
14041 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14042 PyObject *pyobj;
14043
14044 {
14045 #if wxUSE_UNICODE
14046 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14047 #else
14048 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14049 #endif
14050 }
14051 return pyobj;
14052 }
14053
14054
14055 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14056 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14057 return 1;
14058 }
14059
14060
14061 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14062 PyObject *pyobj;
14063
14064 {
14065 #if wxUSE_UNICODE
14066 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14067 #else
14068 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14069 #endif
14070 }
14071 return pyobj;
14072 }
14073
14074
14075 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14076 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14077 return 1;
14078 }
14079
14080
14081 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14082 PyObject *pyobj;
14083
14084 {
14085 #if wxUSE_UNICODE
14086 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14087 #else
14088 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14089 #endif
14090 }
14091 return pyobj;
14092 }
14093
14094
14095 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14096 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14097 return 1;
14098 }
14099
14100
14101 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14102 PyObject *pyobj;
14103
14104 {
14105 #if wxUSE_UNICODE
14106 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14107 #else
14108 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14109 #endif
14110 }
14111 return pyobj;
14112 }
14113
14114
14115 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14116 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14117 return 1;
14118 }
14119
14120
14121 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14122 PyObject *pyobj;
14123
14124 {
14125 #if wxUSE_UNICODE
14126 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14127 #else
14128 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14129 #endif
14130 }
14131 return pyobj;
14132 }
14133
14134
14135 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14136 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14137 return 1;
14138 }
14139
14140
14141 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14142 PyObject *pyobj;
14143
14144 {
14145 #if wxUSE_UNICODE
14146 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14147 #else
14148 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14149 #endif
14150 }
14151 return pyobj;
14152 }
14153
14154
14155 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj;
14157 wxBMPHandler *result;
14158 char *kwnames[] = {
14159 NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 result = (wxBMPHandler *)new wxBMPHandler();
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14178 PyObject *obj;
14179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14180 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14181 Py_INCREF(obj);
14182 return Py_BuildValue((char *)"");
14183 }
14184 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxICOHandler *result;
14187 char *kwnames[] = {
14188 NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (wxICOHandler *)new wxICOHandler();
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14207 PyObject *obj;
14208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14209 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14210 Py_INCREF(obj);
14211 return Py_BuildValue((char *)"");
14212 }
14213 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj;
14215 wxCURHandler *result;
14216 char *kwnames[] = {
14217 NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 result = (wxCURHandler *)new wxCURHandler();
14224
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14236 PyObject *obj;
14237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14238 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14239 Py_INCREF(obj);
14240 return Py_BuildValue((char *)"");
14241 }
14242 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxANIHandler *result;
14245 char *kwnames[] = {
14246 NULL
14247 };
14248
14249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (wxANIHandler *)new wxANIHandler();
14253
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14258 return resultobj;
14259 fail:
14260 return NULL;
14261 }
14262
14263
14264 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14265 PyObject *obj;
14266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14267 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14268 Py_INCREF(obj);
14269 return Py_BuildValue((char *)"");
14270 }
14271 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj;
14273 wxPNGHandler *result;
14274 char *kwnames[] = {
14275 NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 result = (wxPNGHandler *)new wxPNGHandler();
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14287 return resultobj;
14288 fail:
14289 return NULL;
14290 }
14291
14292
14293 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14294 PyObject *obj;
14295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14296 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14297 Py_INCREF(obj);
14298 return Py_BuildValue((char *)"");
14299 }
14300 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxGIFHandler *result;
14303 char *kwnames[] = {
14304 NULL
14305 };
14306
14307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 result = (wxGIFHandler *)new wxGIFHandler();
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14323 PyObject *obj;
14324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14325 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14326 Py_INCREF(obj);
14327 return Py_BuildValue((char *)"");
14328 }
14329 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj;
14331 wxPCXHandler *result;
14332 char *kwnames[] = {
14333 NULL
14334 };
14335
14336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (wxPCXHandler *)new wxPCXHandler();
14340
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14352 PyObject *obj;
14353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14354 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14355 Py_INCREF(obj);
14356 return Py_BuildValue((char *)"");
14357 }
14358 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxJPEGHandler *result;
14361 char *kwnames[] = {
14362 NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (wxJPEGHandler *)new wxJPEGHandler();
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14381 PyObject *obj;
14382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14383 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14384 Py_INCREF(obj);
14385 return Py_BuildValue((char *)"");
14386 }
14387 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj;
14389 wxPNMHandler *result;
14390 char *kwnames[] = {
14391 NULL
14392 };
14393
14394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (wxPNMHandler *)new wxPNMHandler();
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14410 PyObject *obj;
14411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14412 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14413 Py_INCREF(obj);
14414 return Py_BuildValue((char *)"");
14415 }
14416 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxXPMHandler *result;
14419 char *kwnames[] = {
14420 NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxXPMHandler *)new wxXPMHandler();
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14439 PyObject *obj;
14440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14441 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14442 Py_INCREF(obj);
14443 return Py_BuildValue((char *)"");
14444 }
14445 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxTIFFHandler *result;
14448 char *kwnames[] = {
14449 NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (wxTIFFHandler *)new wxTIFFHandler();
14456
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14461 return resultobj;
14462 fail:
14463 return NULL;
14464 }
14465
14466
14467 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14468 PyObject *obj;
14469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14470 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14471 Py_INCREF(obj);
14472 return Py_BuildValue((char *)"");
14473 }
14474 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxImage *arg1 = 0 ;
14477 wxImage *arg2 = 0 ;
14478 int arg3 = (int) 236 ;
14479 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14480 bool result;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 PyObject * obj3 = 0 ;
14485 char *kwnames[] = {
14486 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14487 };
14488
14489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14490 {
14491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14492 if (SWIG_arg_fail(1)) SWIG_fail;
14493 if (arg1 == NULL) {
14494 SWIG_null_ref("wxImage");
14495 }
14496 if (SWIG_arg_fail(1)) SWIG_fail;
14497 }
14498 {
14499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(2)) SWIG_fail;
14501 if (arg2 == NULL) {
14502 SWIG_null_ref("wxImage");
14503 }
14504 if (SWIG_arg_fail(2)) SWIG_fail;
14505 }
14506 if (obj2) {
14507 {
14508 arg3 = (int)(SWIG_As_int(obj2));
14509 if (SWIG_arg_fail(3)) SWIG_fail;
14510 }
14511 }
14512 if (obj3) {
14513 {
14514 arg4 = (int)(SWIG_As_int(obj3));
14515 if (SWIG_arg_fail(4)) SWIG_fail;
14516 }
14517 }
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14521
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14535 PyObject *obj;
14536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14537 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14538 Py_INCREF(obj);
14539 return Py_BuildValue((char *)"");
14540 }
14541 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14542 PyObject *resultobj;
14543 wxEvtHandler *result;
14544 char *kwnames[] = {
14545 NULL
14546 };
14547
14548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14549 {
14550 PyThreadState* __tstate = wxPyBeginAllowThreads();
14551 result = (wxEvtHandler *)new wxEvtHandler();
14552
14553 wxPyEndAllowThreads(__tstate);
14554 if (PyErr_Occurred()) SWIG_fail;
14555 }
14556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14557 return resultobj;
14558 fail:
14559 return NULL;
14560 }
14561
14562
14563 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj;
14565 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14566 wxEvtHandler *result;
14567 PyObject * obj0 = 0 ;
14568 char *kwnames[] = {
14569 (char *) "self", NULL
14570 };
14571
14572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14574 if (SWIG_arg_fail(1)) SWIG_fail;
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14578
14579 wxPyEndAllowThreads(__tstate);
14580 if (PyErr_Occurred()) SWIG_fail;
14581 }
14582 {
14583 resultobj = wxPyMake_wxObject(result, 0);
14584 }
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14592 PyObject *resultobj;
14593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14594 wxEvtHandler *result;
14595 PyObject * obj0 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 {
14611 resultobj = wxPyMake_wxObject(result, 0);
14612 }
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14622 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "handler", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(2)) SWIG_fail;
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 (arg1)->SetNextHandler(arg2);
14637
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 Py_INCREF(Py_None); resultobj = Py_None;
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj;
14650 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14651 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 char *kwnames[] = {
14655 (char *) "self",(char *) "handler", NULL
14656 };
14657
14658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14660 if (SWIG_arg_fail(1)) SWIG_fail;
14661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(2)) SWIG_fail;
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 (arg1)->SetPreviousHandler(arg2);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 Py_INCREF(Py_None); resultobj = Py_None;
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14678 PyObject *resultobj;
14679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14680 bool result;
14681 PyObject * obj0 = 0 ;
14682 char *kwnames[] = {
14683 (char *) "self", NULL
14684 };
14685
14686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14688 if (SWIG_arg_fail(1)) SWIG_fail;
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (bool)(arg1)->GetEvtHandlerEnabled();
14692
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 {
14697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14698 }
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14706 PyObject *resultobj;
14707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14708 bool arg2 ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 char *kwnames[] = {
14712 (char *) "self",(char *) "enabled", NULL
14713 };
14714
14715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14717 if (SWIG_arg_fail(1)) SWIG_fail;
14718 {
14719 arg2 = (bool)(SWIG_As_bool(obj1));
14720 if (SWIG_arg_fail(2)) SWIG_fail;
14721 }
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 (arg1)->SetEvtHandlerEnabled(arg2);
14725
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 Py_INCREF(Py_None); resultobj = Py_None;
14730 return resultobj;
14731 fail:
14732 return NULL;
14733 }
14734
14735
14736 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj;
14738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14739 wxEvent *arg2 = 0 ;
14740 bool result;
14741 PyObject * obj0 = 0 ;
14742 PyObject * obj1 = 0 ;
14743 char *kwnames[] = {
14744 (char *) "self",(char *) "event", NULL
14745 };
14746
14747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14749 if (SWIG_arg_fail(1)) SWIG_fail;
14750 {
14751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(2)) SWIG_fail;
14753 if (arg2 == NULL) {
14754 SWIG_null_ref("wxEvent");
14755 }
14756 if (SWIG_arg_fail(2)) SWIG_fail;
14757 }
14758 {
14759 PyThreadState* __tstate = wxPyBeginAllowThreads();
14760 result = (bool)(arg1)->ProcessEvent(*arg2);
14761
14762 wxPyEndAllowThreads(__tstate);
14763 if (PyErr_Occurred()) SWIG_fail;
14764 }
14765 {
14766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14767 }
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj;
14776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14777 wxEvent *arg2 = 0 ;
14778 PyObject * obj0 = 0 ;
14779 PyObject * obj1 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "event", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 {
14788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 if (arg2 == NULL) {
14791 SWIG_null_ref("wxEvent");
14792 }
14793 if (SWIG_arg_fail(2)) SWIG_fail;
14794 }
14795 {
14796 PyThreadState* __tstate = wxPyBeginAllowThreads();
14797 (arg1)->AddPendingEvent(*arg2);
14798
14799 wxPyEndAllowThreads(__tstate);
14800 if (PyErr_Occurred()) SWIG_fail;
14801 }
14802 Py_INCREF(Py_None); resultobj = Py_None;
14803 return resultobj;
14804 fail:
14805 return NULL;
14806 }
14807
14808
14809 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14810 PyObject *resultobj;
14811 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14812 PyObject * obj0 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 (arg1)->ProcessPendingEvents();
14823
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 Py_INCREF(Py_None); resultobj = Py_None;
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14835 PyObject *resultobj;
14836 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14837 int arg2 ;
14838 int arg3 ;
14839 int arg4 ;
14840 PyObject *arg5 = (PyObject *) 0 ;
14841 PyObject * obj0 = 0 ;
14842 PyObject * obj1 = 0 ;
14843 PyObject * obj2 = 0 ;
14844 PyObject * obj3 = 0 ;
14845 PyObject * obj4 = 0 ;
14846 char *kwnames[] = {
14847 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14848 };
14849
14850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14852 if (SWIG_arg_fail(1)) SWIG_fail;
14853 {
14854 arg2 = (int)(SWIG_As_int(obj1));
14855 if (SWIG_arg_fail(2)) SWIG_fail;
14856 }
14857 {
14858 arg3 = (int)(SWIG_As_int(obj2));
14859 if (SWIG_arg_fail(3)) SWIG_fail;
14860 }
14861 {
14862 arg4 = (int)(SWIG_As_int(obj3));
14863 if (SWIG_arg_fail(4)) SWIG_fail;
14864 }
14865 arg5 = obj4;
14866 {
14867 PyThreadState* __tstate = wxPyBeginAllowThreads();
14868 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14869
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 Py_INCREF(Py_None); resultobj = Py_None;
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj;
14882 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14883 int arg2 ;
14884 int arg3 = (int) -1 ;
14885 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14886 bool result;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 PyObject * obj3 = 0 ;
14891 char *kwnames[] = {
14892 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14893 };
14894
14895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14897 if (SWIG_arg_fail(1)) SWIG_fail;
14898 {
14899 arg2 = (int)(SWIG_As_int(obj1));
14900 if (SWIG_arg_fail(2)) SWIG_fail;
14901 }
14902 if (obj2) {
14903 {
14904 arg3 = (int)(SWIG_As_int(obj2));
14905 if (SWIG_arg_fail(3)) SWIG_fail;
14906 }
14907 }
14908 if (obj3) {
14909 {
14910 arg4 = (wxEventType)(SWIG_As_int(obj3));
14911 if (SWIG_arg_fail(4)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14923 }
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj;
14932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14933 PyObject *arg2 = (PyObject *) 0 ;
14934 bool arg3 = (bool) true ;
14935 PyObject * obj0 = 0 ;
14936 PyObject * obj1 = 0 ;
14937 PyObject * obj2 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self",(char *) "_self",(char *) "incref", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 arg2 = obj1;
14946 if (obj2) {
14947 {
14948 arg3 = (bool)(SWIG_As_bool(obj2));
14949 if (SWIG_arg_fail(3)) SWIG_fail;
14950 }
14951 }
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14955
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 Py_INCREF(Py_None); resultobj = Py_None;
14960 return resultobj;
14961 fail:
14962 return NULL;
14963 }
14964
14965
14966 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14967 PyObject *obj;
14968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14970 Py_INCREF(obj);
14971 return Py_BuildValue((char *)"");
14972 }
14973 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj;
14975 wxEventType result;
14976 char *kwnames[] = {
14977 NULL
14978 };
14979
14980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (wxEventType)wxNewEventType();
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = SWIG_From_int((int)(result));
14990 }
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxEvent *arg1 = (wxEvent *) 0 ;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 delete arg1;
15011
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 Py_INCREF(Py_None); resultobj = Py_None;
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj;
15024 wxEvent *arg1 = (wxEvent *) 0 ;
15025 wxEventType arg2 ;
15026 PyObject * obj0 = 0 ;
15027 PyObject * obj1 = 0 ;
15028 char *kwnames[] = {
15029 (char *) "self",(char *) "typ", NULL
15030 };
15031
15032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15034 if (SWIG_arg_fail(1)) SWIG_fail;
15035 {
15036 arg2 = (wxEventType)(SWIG_As_int(obj1));
15037 if (SWIG_arg_fail(2)) SWIG_fail;
15038 }
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 (arg1)->SetEventType(arg2);
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 Py_INCREF(Py_None); resultobj = Py_None;
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15054 PyObject *resultobj;
15055 wxEvent *arg1 = (wxEvent *) 0 ;
15056 wxEventType result;
15057 PyObject * obj0 = 0 ;
15058 char *kwnames[] = {
15059 (char *) "self", NULL
15060 };
15061
15062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15064 if (SWIG_arg_fail(1)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 {
15073 resultobj = SWIG_From_int((int)(result));
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxEvent *arg1 = (wxEvent *) 0 ;
15084 wxObject *result;
15085 PyObject * obj0 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15096
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 {
15101 resultobj = wxPyMake_wxObject(result, 0);
15102 }
15103 return resultobj;
15104 fail:
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxEvent *arg1 = (wxEvent *) 0 ;
15112 wxObject *arg2 = (wxObject *) 0 ;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "self",(char *) "obj", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15121 if (SWIG_arg_fail(1)) SWIG_fail;
15122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15123 if (SWIG_arg_fail(2)) SWIG_fail;
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->SetEventObject(arg2);
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 Py_INCREF(Py_None); resultobj = Py_None;
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15139 PyObject *resultobj;
15140 wxEvent *arg1 = (wxEvent *) 0 ;
15141 long result;
15142 PyObject * obj0 = 0 ;
15143 char *kwnames[] = {
15144 (char *) "self", NULL
15145 };
15146
15147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15149 if (SWIG_arg_fail(1)) SWIG_fail;
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 {
15158 resultobj = SWIG_From_long((long)(result));
15159 }
15160 return resultobj;
15161 fail:
15162 return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15167 PyObject *resultobj;
15168 wxEvent *arg1 = (wxEvent *) 0 ;
15169 long arg2 = (long) 0 ;
15170 PyObject * obj0 = 0 ;
15171 PyObject * obj1 = 0 ;
15172 char *kwnames[] = {
15173 (char *) "self",(char *) "ts", NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15178 if (SWIG_arg_fail(1)) SWIG_fail;
15179 if (obj1) {
15180 {
15181 arg2 = (long)(SWIG_As_long(obj1));
15182 if (SWIG_arg_fail(2)) SWIG_fail;
15183 }
15184 }
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 (arg1)->SetTimestamp(arg2);
15188
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 Py_INCREF(Py_None); resultobj = Py_None;
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15200 PyObject *resultobj;
15201 wxEvent *arg1 = (wxEvent *) 0 ;
15202 int result;
15203 PyObject * obj0 = 0 ;
15204 char *kwnames[] = {
15205 (char *) "self", NULL
15206 };
15207
15208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15210 if (SWIG_arg_fail(1)) SWIG_fail;
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 result = (int)((wxEvent const *)arg1)->GetId();
15214
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 {
15219 resultobj = SWIG_From_int((int)(result));
15220 }
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj;
15229 wxEvent *arg1 = (wxEvent *) 0 ;
15230 int arg2 ;
15231 PyObject * obj0 = 0 ;
15232 PyObject * obj1 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self",(char *) "Id", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 arg2 = (int)(SWIG_As_int(obj1));
15242 if (SWIG_arg_fail(2)) SWIG_fail;
15243 }
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 (arg1)->SetId(arg2);
15247
15248 wxPyEndAllowThreads(__tstate);
15249 if (PyErr_Occurred()) SWIG_fail;
15250 }
15251 Py_INCREF(Py_None); resultobj = Py_None;
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxEvent *arg1 = (wxEvent *) 0 ;
15261 bool result;
15262 PyObject * obj0 = 0 ;
15263 char *kwnames[] = {
15264 (char *) "self", NULL
15265 };
15266
15267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15269 if (SWIG_arg_fail(1)) SWIG_fail;
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15273
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 {
15278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15279 }
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj;
15288 wxEvent *arg1 = (wxEvent *) 0 ;
15289 bool arg2 = (bool) true ;
15290 PyObject * obj0 = 0 ;
15291 PyObject * obj1 = 0 ;
15292 char *kwnames[] = {
15293 (char *) "self",(char *) "skip", NULL
15294 };
15295
15296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15298 if (SWIG_arg_fail(1)) SWIG_fail;
15299 if (obj1) {
15300 {
15301 arg2 = (bool)(SWIG_As_bool(obj1));
15302 if (SWIG_arg_fail(2)) SWIG_fail;
15303 }
15304 }
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 (arg1)->Skip(arg2);
15308
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 Py_INCREF(Py_None); resultobj = Py_None;
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxEvent *arg1 = (wxEvent *) 0 ;
15322 bool result;
15323 PyObject * obj0 = 0 ;
15324 char *kwnames[] = {
15325 (char *) "self", NULL
15326 };
15327
15328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15330 if (SWIG_arg_fail(1)) SWIG_fail;
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15340 }
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxEvent *arg1 = (wxEvent *) 0 ;
15350 bool result;
15351 PyObject * obj0 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15362
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 {
15367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15368 }
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15376 PyObject *resultobj;
15377 wxEvent *arg1 = (wxEvent *) 0 ;
15378 int result;
15379 PyObject * obj0 = 0 ;
15380 char *kwnames[] = {
15381 (char *) "self", NULL
15382 };
15383
15384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(1)) SWIG_fail;
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (int)(arg1)->StopPropagation();
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 {
15395 resultobj = SWIG_From_int((int)(result));
15396 }
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15404 PyObject *resultobj;
15405 wxEvent *arg1 = (wxEvent *) 0 ;
15406 int arg2 ;
15407 PyObject * obj0 = 0 ;
15408 PyObject * obj1 = 0 ;
15409 char *kwnames[] = {
15410 (char *) "self",(char *) "propagationLevel", NULL
15411 };
15412
15413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15415 if (SWIG_arg_fail(1)) SWIG_fail;
15416 {
15417 arg2 = (int)(SWIG_As_int(obj1));
15418 if (SWIG_arg_fail(2)) SWIG_fail;
15419 }
15420 {
15421 PyThreadState* __tstate = wxPyBeginAllowThreads();
15422 (arg1)->ResumePropagation(arg2);
15423
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 Py_INCREF(Py_None); resultobj = Py_None;
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15435 PyObject *resultobj;
15436 wxEvent *arg1 = (wxEvent *) 0 ;
15437 wxEvent *result;
15438 PyObject * obj0 = 0 ;
15439 char *kwnames[] = {
15440 (char *) "self", NULL
15441 };
15442
15443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15445 if (SWIG_arg_fail(1)) SWIG_fail;
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (wxEvent *)(arg1)->Clone();
15449
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15461 PyObject *obj;
15462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15463 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15464 Py_INCREF(obj);
15465 return Py_BuildValue((char *)"");
15466 }
15467 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15468 PyObject *resultobj;
15469 wxEvent *arg1 = 0 ;
15470 wxPropagationDisabler *result;
15471 PyObject * obj0 = 0 ;
15472 char *kwnames[] = {
15473 (char *) "event", NULL
15474 };
15475
15476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15477 {
15478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 if (arg1 == NULL) {
15481 SWIG_null_ref("wxEvent");
15482 }
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 }
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15488
15489 wxPyEndAllowThreads(__tstate);
15490 if (PyErr_Occurred()) SWIG_fail;
15491 }
15492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj;
15501 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15502 PyObject * obj0 = 0 ;
15503 char *kwnames[] = {
15504 (char *) "self", NULL
15505 };
15506
15507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15509 if (SWIG_arg_fail(1)) SWIG_fail;
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 delete arg1;
15513
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 Py_INCREF(Py_None); resultobj = Py_None;
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15525 PyObject *obj;
15526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15527 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15528 Py_INCREF(obj);
15529 return Py_BuildValue((char *)"");
15530 }
15531 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj;
15533 wxEvent *arg1 = 0 ;
15534 wxPropagateOnce *result;
15535 PyObject * obj0 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "event", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15541 {
15542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 if (arg1 == NULL) {
15545 SWIG_null_ref("wxEvent");
15546 }
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 }
15549 {
15550 PyThreadState* __tstate = wxPyBeginAllowThreads();
15551 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15552
15553 wxPyEndAllowThreads(__tstate);
15554 if (PyErr_Occurred()) SWIG_fail;
15555 }
15556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15564 PyObject *resultobj;
15565 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15566 PyObject * obj0 = 0 ;
15567 char *kwnames[] = {
15568 (char *) "self", NULL
15569 };
15570
15571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15573 if (SWIG_arg_fail(1)) SWIG_fail;
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 delete arg1;
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 Py_INCREF(Py_None); resultobj = Py_None;
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15589 PyObject *obj;
15590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15591 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15592 Py_INCREF(obj);
15593 return Py_BuildValue((char *)"");
15594 }
15595 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15596 PyObject *resultobj;
15597 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15598 int arg2 = (int) 0 ;
15599 wxCommandEvent *result;
15600 PyObject * obj0 = 0 ;
15601 PyObject * obj1 = 0 ;
15602 char *kwnames[] = {
15603 (char *) "commandType",(char *) "winid", NULL
15604 };
15605
15606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15607 if (obj0) {
15608 {
15609 arg1 = (wxEventType)(SWIG_As_int(obj0));
15610 if (SWIG_arg_fail(1)) SWIG_fail;
15611 }
15612 }
15613 if (obj1) {
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 }
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15622
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj;
15635 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15636 int result;
15637 PyObject * obj0 = 0 ;
15638 char *kwnames[] = {
15639 (char *) "self", NULL
15640 };
15641
15642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15644 if (SWIG_arg_fail(1)) SWIG_fail;
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15648
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 {
15653 resultobj = SWIG_From_int((int)(result));
15654 }
15655 return resultobj;
15656 fail:
15657 return NULL;
15658 }
15659
15660
15661 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15662 PyObject *resultobj;
15663 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15664 wxString *arg2 = 0 ;
15665 bool temp2 = false ;
15666 PyObject * obj0 = 0 ;
15667 PyObject * obj1 = 0 ;
15668 char *kwnames[] = {
15669 (char *) "self",(char *) "s", NULL
15670 };
15671
15672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15674 if (SWIG_arg_fail(1)) SWIG_fail;
15675 {
15676 arg2 = wxString_in_helper(obj1);
15677 if (arg2 == NULL) SWIG_fail;
15678 temp2 = true;
15679 }
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 (arg1)->SetString((wxString const &)*arg2);
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 Py_INCREF(Py_None); resultobj = Py_None;
15688 {
15689 if (temp2)
15690 delete arg2;
15691 }
15692 return resultobj;
15693 fail:
15694 {
15695 if (temp2)
15696 delete arg2;
15697 }
15698 return NULL;
15699 }
15700
15701
15702 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15703 PyObject *resultobj;
15704 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15705 wxString result;
15706 PyObject * obj0 = 0 ;
15707 char *kwnames[] = {
15708 (char *) "self", NULL
15709 };
15710
15711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15713 if (SWIG_arg_fail(1)) SWIG_fail;
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 result = ((wxCommandEvent const *)arg1)->GetString();
15717
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 {
15722 #if wxUSE_UNICODE
15723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15724 #else
15725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15726 #endif
15727 }
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15737 bool result;
15738 PyObject * obj0 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15755 }
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj;
15764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15765 bool result;
15766 PyObject * obj0 = 0 ;
15767 char *kwnames[] = {
15768 (char *) "self", NULL
15769 };
15770
15771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15777
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 {
15782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15783 }
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15791 PyObject *resultobj;
15792 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15793 long arg2 ;
15794 PyObject * obj0 = 0 ;
15795 PyObject * obj1 = 0 ;
15796 char *kwnames[] = {
15797 (char *) "self",(char *) "extraLong", NULL
15798 };
15799
15800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15802 if (SWIG_arg_fail(1)) SWIG_fail;
15803 {
15804 arg2 = (long)(SWIG_As_long(obj1));
15805 if (SWIG_arg_fail(2)) SWIG_fail;
15806 }
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 (arg1)->SetExtraLong(arg2);
15810
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 Py_INCREF(Py_None); resultobj = Py_None;
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj;
15823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15824 long result;
15825 PyObject * obj0 = 0 ;
15826 char *kwnames[] = {
15827 (char *) "self", NULL
15828 };
15829
15830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15832 if (SWIG_arg_fail(1)) SWIG_fail;
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15836
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 {
15841 resultobj = SWIG_From_long((long)(result));
15842 }
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj;
15851 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15852 int arg2 ;
15853 PyObject * obj0 = 0 ;
15854 PyObject * obj1 = 0 ;
15855 char *kwnames[] = {
15856 (char *) "self",(char *) "i", NULL
15857 };
15858
15859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15861 if (SWIG_arg_fail(1)) SWIG_fail;
15862 {
15863 arg2 = (int)(SWIG_As_int(obj1));
15864 if (SWIG_arg_fail(2)) SWIG_fail;
15865 }
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 (arg1)->SetInt(arg2);
15869
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 Py_INCREF(Py_None); resultobj = Py_None;
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15881 PyObject *resultobj;
15882 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15883 long result;
15884 PyObject * obj0 = 0 ;
15885 char *kwnames[] = {
15886 (char *) "self", NULL
15887 };
15888
15889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15891 if (SWIG_arg_fail(1)) SWIG_fail;
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15895
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 {
15900 resultobj = SWIG_From_long((long)(result));
15901 }
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15909 PyObject *resultobj;
15910 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15911 wxEvent *result;
15912 PyObject * obj0 = 0 ;
15913 char *kwnames[] = {
15914 (char *) "self", NULL
15915 };
15916
15917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15919 if (SWIG_arg_fail(1)) SWIG_fail;
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15923
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15935 PyObject *obj;
15936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15937 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15938 Py_INCREF(obj);
15939 return Py_BuildValue((char *)"");
15940 }
15941 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj;
15943 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15944 int arg2 = (int) 0 ;
15945 wxNotifyEvent *result;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 char *kwnames[] = {
15949 (char *) "commandType",(char *) "winid", NULL
15950 };
15951
15952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15953 if (obj0) {
15954 {
15955 arg1 = (wxEventType)(SWIG_As_int(obj0));
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 }
15958 }
15959 if (obj1) {
15960 {
15961 arg2 = (int)(SWIG_As_int(obj1));
15962 if (SWIG_arg_fail(2)) SWIG_fail;
15963 }
15964 }
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15968
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj;
15981 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15982 PyObject * obj0 = 0 ;
15983 char *kwnames[] = {
15984 (char *) "self", NULL
15985 };
15986
15987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15989 if (SWIG_arg_fail(1)) SWIG_fail;
15990 {
15991 PyThreadState* __tstate = wxPyBeginAllowThreads();
15992 (arg1)->Veto();
15993
15994 wxPyEndAllowThreads(__tstate);
15995 if (PyErr_Occurred()) SWIG_fail;
15996 }
15997 Py_INCREF(Py_None); resultobj = Py_None;
15998 return resultobj;
15999 fail:
16000 return NULL;
16001 }
16002
16003
16004 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16005 PyObject *resultobj;
16006 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16007 PyObject * obj0 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 (arg1)->Allow();
16018
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 Py_INCREF(Py_None); resultobj = Py_None;
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16032 bool result;
16033 PyObject * obj0 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)(arg1)->IsAllowed();
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16058 PyObject *obj;
16059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16060 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16061 Py_INCREF(obj);
16062 return Py_BuildValue((char *)"");
16063 }
16064 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj;
16066 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16067 int arg2 = (int) 0 ;
16068 int arg3 = (int) 0 ;
16069 int arg4 = (int) 0 ;
16070 wxScrollEvent *result;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 PyObject * obj2 = 0 ;
16074 PyObject * obj3 = 0 ;
16075 char *kwnames[] = {
16076 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16077 };
16078
16079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16080 if (obj0) {
16081 {
16082 arg1 = (wxEventType)(SWIG_As_int(obj0));
16083 if (SWIG_arg_fail(1)) SWIG_fail;
16084 }
16085 }
16086 if (obj1) {
16087 {
16088 arg2 = (int)(SWIG_As_int(obj1));
16089 if (SWIG_arg_fail(2)) SWIG_fail;
16090 }
16091 }
16092 if (obj2) {
16093 {
16094 arg3 = (int)(SWIG_As_int(obj2));
16095 if (SWIG_arg_fail(3)) SWIG_fail;
16096 }
16097 }
16098 if (obj3) {
16099 {
16100 arg4 = (int)(SWIG_As_int(obj3));
16101 if (SWIG_arg_fail(4)) SWIG_fail;
16102 }
16103 }
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16121 int result;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16129 if (SWIG_arg_fail(1)) SWIG_fail;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = SWIG_From_int((int)(result));
16139 }
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16147 PyObject *resultobj;
16148 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16149 int result;
16150 PyObject * obj0 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 {
16166 resultobj = SWIG_From_int((int)(result));
16167 }
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj;
16176 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16177 int arg2 ;
16178 PyObject * obj0 = 0 ;
16179 PyObject * obj1 = 0 ;
16180 char *kwnames[] = {
16181 (char *) "self",(char *) "orient", NULL
16182 };
16183
16184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16186 if (SWIG_arg_fail(1)) SWIG_fail;
16187 {
16188 arg2 = (int)(SWIG_As_int(obj1));
16189 if (SWIG_arg_fail(2)) SWIG_fail;
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 (arg1)->SetOrientation(arg2);
16194
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 Py_INCREF(Py_None); resultobj = Py_None;
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj;
16207 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16208 int arg2 ;
16209 PyObject * obj0 = 0 ;
16210 PyObject * obj1 = 0 ;
16211 char *kwnames[] = {
16212 (char *) "self",(char *) "pos", NULL
16213 };
16214
16215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16217 if (SWIG_arg_fail(1)) SWIG_fail;
16218 {
16219 arg2 = (int)(SWIG_As_int(obj1));
16220 if (SWIG_arg_fail(2)) SWIG_fail;
16221 }
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 (arg1)->SetPosition(arg2);
16225
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 Py_INCREF(Py_None); resultobj = Py_None;
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16237 PyObject *obj;
16238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16239 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16240 Py_INCREF(obj);
16241 return Py_BuildValue((char *)"");
16242 }
16243 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj;
16245 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16246 int arg2 = (int) 0 ;
16247 int arg3 = (int) 0 ;
16248 wxScrollWinEvent *result;
16249 PyObject * obj0 = 0 ;
16250 PyObject * obj1 = 0 ;
16251 PyObject * obj2 = 0 ;
16252 char *kwnames[] = {
16253 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16254 };
16255
16256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16257 if (obj0) {
16258 {
16259 arg1 = (wxEventType)(SWIG_As_int(obj0));
16260 if (SWIG_arg_fail(1)) SWIG_fail;
16261 }
16262 }
16263 if (obj1) {
16264 {
16265 arg2 = (int)(SWIG_As_int(obj1));
16266 if (SWIG_arg_fail(2)) SWIG_fail;
16267 }
16268 }
16269 if (obj2) {
16270 {
16271 arg3 = (int)(SWIG_As_int(obj2));
16272 if (SWIG_arg_fail(3)) SWIG_fail;
16273 }
16274 }
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16278
16279 wxPyEndAllowThreads(__tstate);
16280 if (PyErr_Occurred()) SWIG_fail;
16281 }
16282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16292 int result;
16293 PyObject * obj0 = 0 ;
16294 char *kwnames[] = {
16295 (char *) "self", NULL
16296 };
16297
16298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16304
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = SWIG_From_int((int)(result));
16310 }
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj;
16319 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16320 int result;
16321 PyObject * obj0 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16332
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 {
16337 resultobj = SWIG_From_int((int)(result));
16338 }
16339 return resultobj;
16340 fail:
16341 return NULL;
16342 }
16343
16344
16345 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16346 PyObject *resultobj;
16347 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16348 int arg2 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self",(char *) "orient", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 arg2 = (int)(SWIG_As_int(obj1));
16360 if (SWIG_arg_fail(2)) SWIG_fail;
16361 }
16362 {
16363 PyThreadState* __tstate = wxPyBeginAllowThreads();
16364 (arg1)->SetOrientation(arg2);
16365
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 Py_INCREF(Py_None); resultobj = Py_None;
16370 return resultobj;
16371 fail:
16372 return NULL;
16373 }
16374
16375
16376 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16377 PyObject *resultobj;
16378 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16379 int arg2 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 char *kwnames[] = {
16383 (char *) "self",(char *) "pos", NULL
16384 };
16385
16386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16388 if (SWIG_arg_fail(1)) SWIG_fail;
16389 {
16390 arg2 = (int)(SWIG_As_int(obj1));
16391 if (SWIG_arg_fail(2)) SWIG_fail;
16392 }
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 (arg1)->SetPosition(arg2);
16396
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 Py_INCREF(Py_None); resultobj = Py_None;
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16408 PyObject *obj;
16409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16410 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16411 Py_INCREF(obj);
16412 return Py_BuildValue((char *)"");
16413 }
16414 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj;
16416 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16417 wxMouseEvent *result;
16418 PyObject * obj0 = 0 ;
16419 char *kwnames[] = {
16420 (char *) "mouseType", NULL
16421 };
16422
16423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16424 if (obj0) {
16425 {
16426 arg1 = (wxEventType)(SWIG_As_int(obj0));
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 }
16429 }
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16433
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 {
16438 resultobj = wxPyMake_wxObject(result, 1);
16439 }
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16449 bool result;
16450 PyObject * obj0 = 0 ;
16451 char *kwnames[] = {
16452 (char *) "self", NULL
16453 };
16454
16455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16457 if (SWIG_arg_fail(1)) SWIG_fail;
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16461
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 {
16466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16467 }
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16477 int arg2 = (int) wxMOUSE_BTN_ANY ;
16478 bool result;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 char *kwnames[] = {
16482 (char *) "self",(char *) "but", NULL
16483 };
16484
16485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16487 if (SWIG_arg_fail(1)) SWIG_fail;
16488 if (obj1) {
16489 {
16490 arg2 = (int)(SWIG_As_int(obj1));
16491 if (SWIG_arg_fail(2)) SWIG_fail;
16492 }
16493 }
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16503 }
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj;
16512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16513 int arg2 = (int) wxMOUSE_BTN_ANY ;
16514 bool result;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 char *kwnames[] = {
16518 (char *) "self",(char *) "but", NULL
16519 };
16520
16521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16523 if (SWIG_arg_fail(1)) SWIG_fail;
16524 if (obj1) {
16525 {
16526 arg2 = (int)(SWIG_As_int(obj1));
16527 if (SWIG_arg_fail(2)) SWIG_fail;
16528 }
16529 }
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 {
16538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16539 }
16540 return resultobj;
16541 fail:
16542 return NULL;
16543 }
16544
16545
16546 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16547 PyObject *resultobj;
16548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16549 int arg2 = (int) wxMOUSE_BTN_ANY ;
16550 bool result;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 char *kwnames[] = {
16554 (char *) "self",(char *) "but", NULL
16555 };
16556
16557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16559 if (SWIG_arg_fail(1)) SWIG_fail;
16560 if (obj1) {
16561 {
16562 arg2 = (int)(SWIG_As_int(obj1));
16563 if (SWIG_arg_fail(2)) SWIG_fail;
16564 }
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16575 }
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16585 int arg2 ;
16586 bool result;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self",(char *) "button", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16595 if (SWIG_arg_fail(1)) SWIG_fail;
16596 {
16597 arg2 = (int)(SWIG_As_int(obj1));
16598 if (SWIG_arg_fail(2)) SWIG_fail;
16599 }
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 {
16608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16609 }
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj;
16618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16619 int arg2 ;
16620 bool result;
16621 PyObject * obj0 = 0 ;
16622 PyObject * obj1 = 0 ;
16623 char *kwnames[] = {
16624 (char *) "self",(char *) "but", NULL
16625 };
16626
16627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16629 if (SWIG_arg_fail(1)) SWIG_fail;
16630 {
16631 arg2 = (int)(SWIG_As_int(obj1));
16632 if (SWIG_arg_fail(2)) SWIG_fail;
16633 }
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj;
16652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16653 int result;
16654 PyObject * obj0 = 0 ;
16655 char *kwnames[] = {
16656 (char *) "self", NULL
16657 };
16658
16659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16661 if (SWIG_arg_fail(1)) SWIG_fail;
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16665
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 {
16670 resultobj = SWIG_From_int((int)(result));
16671 }
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16681 bool result;
16682 PyObject * obj0 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "self", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16709 bool result;
16710 PyObject * obj0 = 0 ;
16711 char *kwnames[] = {
16712 (char *) "self", NULL
16713 };
16714
16715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16717 if (SWIG_arg_fail(1)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16727 }
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj;
16736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16737 bool result;
16738 PyObject * obj0 = 0 ;
16739 char *kwnames[] = {
16740 (char *) "self", NULL
16741 };
16742
16743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16745 if (SWIG_arg_fail(1)) SWIG_fail;
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16749
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 {
16754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16755 }
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16765 bool result;
16766 PyObject * obj0 = 0 ;
16767 char *kwnames[] = {
16768 (char *) "self", NULL
16769 };
16770
16771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16773 if (SWIG_arg_fail(1)) SWIG_fail;
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16777
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 {
16782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16793 bool result;
16794 PyObject * obj0 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj;
16820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16821 bool result;
16822 PyObject * obj0 = 0 ;
16823 char *kwnames[] = {
16824 (char *) "self", NULL
16825 };
16826
16827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16829 if (SWIG_arg_fail(1)) SWIG_fail;
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16833
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 {
16838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16839 }
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16849 bool result;
16850 PyObject * obj0 = 0 ;
16851 char *kwnames[] = {
16852 (char *) "self", NULL
16853 };
16854
16855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16857 if (SWIG_arg_fail(1)) SWIG_fail;
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16861
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 {
16866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16867 }
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj;
16876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16877 bool result;
16878 PyObject * obj0 = 0 ;
16879 char *kwnames[] = {
16880 (char *) "self", NULL
16881 };
16882
16883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16885 if (SWIG_arg_fail(1)) SWIG_fail;
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16889
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 {
16894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16895 }
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16903 PyObject *resultobj;
16904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16905 bool result;
16906 PyObject * obj0 = 0 ;
16907 char *kwnames[] = {
16908 (char *) "self", NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16913 if (SWIG_arg_fail(1)) SWIG_fail;
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16917
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj;
16932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16933 bool result;
16934 PyObject * obj0 = 0 ;
16935 char *kwnames[] = {
16936 (char *) "self", NULL
16937 };
16938
16939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 {
16950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16951 }
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16961 bool result;
16962 PyObject * obj0 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16973
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 {
16978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16979 }
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16989 bool result;
16990 PyObject * obj0 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 bool result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 {
17034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17035 }
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17045 bool result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17073 bool result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (bool)(arg1)->LeftIsDown();
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 {
17090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17091 }
17092 return resultobj;
17093 fail:
17094 return NULL;
17095 }
17096
17097
17098 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17099 PyObject *resultobj;
17100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17101 bool result;
17102 PyObject * obj0 = 0 ;
17103 char *kwnames[] = {
17104 (char *) "self", NULL
17105 };
17106
17107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 PyThreadState* __tstate = wxPyBeginAllowThreads();
17112 result = (bool)(arg1)->MiddleIsDown();
17113
17114 wxPyEndAllowThreads(__tstate);
17115 if (PyErr_Occurred()) SWIG_fail;
17116 }
17117 {
17118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17119 }
17120 return resultobj;
17121 fail:
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17129 bool result;
17130 PyObject * obj0 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (bool)(arg1)->RightIsDown();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 {
17146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17147 }
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17157 bool result;
17158 PyObject * obj0 = 0 ;
17159 char *kwnames[] = {
17160 (char *) "self", NULL
17161 };
17162
17163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17165 if (SWIG_arg_fail(1)) SWIG_fail;
17166 {
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 {
17174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17175 }
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
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_Moving",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)->Moving();
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_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj;
17240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17241 bool result;
17242 PyObject * obj0 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(1)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj;
17268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17269 wxPoint result;
17270 PyObject * obj0 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (arg1)->GetPosition();
17281
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 wxPoint * resultptr;
17287 resultptr = new wxPoint((wxPoint &)(result));
17288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17289 }
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj;
17298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17299 long *arg2 = (long *) 0 ;
17300 long *arg3 = (long *) 0 ;
17301 long temp2 ;
17302 int res2 = 0 ;
17303 long temp3 ;
17304 int res3 = 0 ;
17305 PyObject * obj0 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self", NULL
17308 };
17309
17310 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17311 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 {
17316 PyThreadState* __tstate = wxPyBeginAllowThreads();
17317 (arg1)->GetPosition(arg2,arg3);
17318
17319 wxPyEndAllowThreads(__tstate);
17320 if (PyErr_Occurred()) SWIG_fail;
17321 }
17322 Py_INCREF(Py_None); resultobj = Py_None;
17323 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17324 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17325 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17326 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17334 PyObject *resultobj;
17335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17336 wxDC *arg2 = 0 ;
17337 wxPoint result;
17338 PyObject * obj0 = 0 ;
17339 PyObject * obj1 = 0 ;
17340 char *kwnames[] = {
17341 (char *) "self",(char *) "dc", NULL
17342 };
17343
17344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(1)) SWIG_fail;
17347 {
17348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17349 if (SWIG_arg_fail(2)) SWIG_fail;
17350 if (arg2 == NULL) {
17351 SWIG_null_ref("wxDC");
17352 }
17353 if (SWIG_arg_fail(2)) SWIG_fail;
17354 }
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17358
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 {
17363 wxPoint * resultptr;
17364 resultptr = new wxPoint((wxPoint &)(result));
17365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17376 int result;
17377 PyObject * obj0 = 0 ;
17378 char *kwnames[] = {
17379 (char *) "self", NULL
17380 };
17381
17382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17384 if (SWIG_arg_fail(1)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (int)((wxMouseEvent const *)arg1)->GetX();
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = SWIG_From_int((int)(result));
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (int)((wxMouseEvent const *)arg1)->GetY();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_int((int)(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 int result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = SWIG_From_int((int)(result));
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 int result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = SWIG_From_int((int)(result));
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17488 int result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = SWIG_From_int((int)(result));
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17516 bool result;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17534 }
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 int arg2 ;
17545 PyObject * obj0 = 0 ;
17546 PyObject * obj1 = 0 ;
17547 char *kwnames[] = {
17548 (char *) "self",(char *) "m_x", NULL
17549 };
17550
17551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17553 if (SWIG_arg_fail(1)) SWIG_fail;
17554 {
17555 arg2 = (int)(SWIG_As_int(obj1));
17556 if (SWIG_arg_fail(2)) SWIG_fail;
17557 }
17558 if (arg1) (arg1)->m_x = arg2;
17559
17560 Py_INCREF(Py_None); resultobj = Py_None;
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17568 PyObject *resultobj;
17569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17570 int result;
17571 PyObject * obj0 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 result = (int) ((arg1)->m_x);
17580
17581 {
17582 resultobj = SWIG_From_int((int)(result));
17583 }
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17593 int arg2 ;
17594 PyObject * obj0 = 0 ;
17595 PyObject * obj1 = 0 ;
17596 char *kwnames[] = {
17597 (char *) "self",(char *) "m_y", NULL
17598 };
17599
17600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17602 if (SWIG_arg_fail(1)) SWIG_fail;
17603 {
17604 arg2 = (int)(SWIG_As_int(obj1));
17605 if (SWIG_arg_fail(2)) SWIG_fail;
17606 }
17607 if (arg1) (arg1)->m_y = arg2;
17608
17609 Py_INCREF(Py_None); resultobj = Py_None;
17610 return resultobj;
17611 fail:
17612 return NULL;
17613 }
17614
17615
17616 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj;
17618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17619 int result;
17620 PyObject * obj0 = 0 ;
17621 char *kwnames[] = {
17622 (char *) "self", NULL
17623 };
17624
17625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17627 if (SWIG_arg_fail(1)) SWIG_fail;
17628 result = (int) ((arg1)->m_y);
17629
17630 {
17631 resultobj = SWIG_From_int((int)(result));
17632 }
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17642 bool arg2 ;
17643 PyObject * obj0 = 0 ;
17644 PyObject * obj1 = 0 ;
17645 char *kwnames[] = {
17646 (char *) "self",(char *) "m_leftDown", NULL
17647 };
17648
17649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17651 if (SWIG_arg_fail(1)) SWIG_fail;
17652 {
17653 arg2 = (bool)(SWIG_As_bool(obj1));
17654 if (SWIG_arg_fail(2)) SWIG_fail;
17655 }
17656 if (arg1) (arg1)->m_leftDown = arg2;
17657
17658 Py_INCREF(Py_None); resultobj = Py_None;
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17668 bool result;
17669 PyObject * obj0 = 0 ;
17670 char *kwnames[] = {
17671 (char *) "self", NULL
17672 };
17673
17674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17676 if (SWIG_arg_fail(1)) SWIG_fail;
17677 result = (bool) ((arg1)->m_leftDown);
17678
17679 {
17680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj;
17690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17691 bool arg2 ;
17692 PyObject * obj0 = 0 ;
17693 PyObject * obj1 = 0 ;
17694 char *kwnames[] = {
17695 (char *) "self",(char *) "m_middleDown", NULL
17696 };
17697
17698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 {
17702 arg2 = (bool)(SWIG_As_bool(obj1));
17703 if (SWIG_arg_fail(2)) SWIG_fail;
17704 }
17705 if (arg1) (arg1)->m_middleDown = arg2;
17706
17707 Py_INCREF(Py_None); resultobj = Py_None;
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj;
17716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17717 bool result;
17718 PyObject * obj0 = 0 ;
17719 char *kwnames[] = {
17720 (char *) "self", NULL
17721 };
17722
17723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17725 if (SWIG_arg_fail(1)) SWIG_fail;
17726 result = (bool) ((arg1)->m_middleDown);
17727
17728 {
17729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj;
17739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17740 bool arg2 ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 char *kwnames[] = {
17744 (char *) "self",(char *) "m_rightDown", NULL
17745 };
17746
17747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17749 if (SWIG_arg_fail(1)) SWIG_fail;
17750 {
17751 arg2 = (bool)(SWIG_As_bool(obj1));
17752 if (SWIG_arg_fail(2)) SWIG_fail;
17753 }
17754 if (arg1) (arg1)->m_rightDown = arg2;
17755
17756 Py_INCREF(Py_None); resultobj = Py_None;
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17766 bool result;
17767 PyObject * obj0 = 0 ;
17768 char *kwnames[] = {
17769 (char *) "self", NULL
17770 };
17771
17772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17774 if (SWIG_arg_fail(1)) SWIG_fail;
17775 result = (bool) ((arg1)->m_rightDown);
17776
17777 {
17778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17779 }
17780 return resultobj;
17781 fail:
17782 return NULL;
17783 }
17784
17785
17786 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17787 PyObject *resultobj;
17788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17789 bool arg2 ;
17790 PyObject * obj0 = 0 ;
17791 PyObject * obj1 = 0 ;
17792 char *kwnames[] = {
17793 (char *) "self",(char *) "m_controlDown", NULL
17794 };
17795
17796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(1)) SWIG_fail;
17799 {
17800 arg2 = (bool)(SWIG_As_bool(obj1));
17801 if (SWIG_arg_fail(2)) SWIG_fail;
17802 }
17803 if (arg1) (arg1)->m_controlDown = arg2;
17804
17805 Py_INCREF(Py_None); resultobj = Py_None;
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17813 PyObject *resultobj;
17814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17815 bool result;
17816 PyObject * obj0 = 0 ;
17817 char *kwnames[] = {
17818 (char *) "self", NULL
17819 };
17820
17821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17823 if (SWIG_arg_fail(1)) SWIG_fail;
17824 result = (bool) ((arg1)->m_controlDown);
17825
17826 {
17827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17828 }
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17838 bool arg2 ;
17839 PyObject * obj0 = 0 ;
17840 PyObject * obj1 = 0 ;
17841 char *kwnames[] = {
17842 (char *) "self",(char *) "m_shiftDown", NULL
17843 };
17844
17845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17847 if (SWIG_arg_fail(1)) SWIG_fail;
17848 {
17849 arg2 = (bool)(SWIG_As_bool(obj1));
17850 if (SWIG_arg_fail(2)) SWIG_fail;
17851 }
17852 if (arg1) (arg1)->m_shiftDown = arg2;
17853
17854 Py_INCREF(Py_None); resultobj = Py_None;
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj;
17863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17864 bool result;
17865 PyObject * obj0 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "self", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17872 if (SWIG_arg_fail(1)) SWIG_fail;
17873 result = (bool) ((arg1)->m_shiftDown);
17874
17875 {
17876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17877 }
17878 return resultobj;
17879 fail:
17880 return NULL;
17881 }
17882
17883
17884 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17885 PyObject *resultobj;
17886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17887 bool arg2 ;
17888 PyObject * obj0 = 0 ;
17889 PyObject * obj1 = 0 ;
17890 char *kwnames[] = {
17891 (char *) "self",(char *) "m_altDown", NULL
17892 };
17893
17894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17896 if (SWIG_arg_fail(1)) SWIG_fail;
17897 {
17898 arg2 = (bool)(SWIG_As_bool(obj1));
17899 if (SWIG_arg_fail(2)) SWIG_fail;
17900 }
17901 if (arg1) (arg1)->m_altDown = arg2;
17902
17903 Py_INCREF(Py_None); resultobj = Py_None;
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj;
17912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17913 bool result;
17914 PyObject * obj0 = 0 ;
17915 char *kwnames[] = {
17916 (char *) "self", NULL
17917 };
17918
17919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17921 if (SWIG_arg_fail(1)) SWIG_fail;
17922 result = (bool) ((arg1)->m_altDown);
17923
17924 {
17925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj;
17935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17936 bool arg2 ;
17937 PyObject * obj0 = 0 ;
17938 PyObject * obj1 = 0 ;
17939 char *kwnames[] = {
17940 (char *) "self",(char *) "m_metaDown", NULL
17941 };
17942
17943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17945 if (SWIG_arg_fail(1)) SWIG_fail;
17946 {
17947 arg2 = (bool)(SWIG_As_bool(obj1));
17948 if (SWIG_arg_fail(2)) SWIG_fail;
17949 }
17950 if (arg1) (arg1)->m_metaDown = arg2;
17951
17952 Py_INCREF(Py_None); resultobj = Py_None;
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17962 bool result;
17963 PyObject * obj0 = 0 ;
17964 char *kwnames[] = {
17965 (char *) "self", NULL
17966 };
17967
17968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17970 if (SWIG_arg_fail(1)) SWIG_fail;
17971 result = (bool) ((arg1)->m_metaDown);
17972
17973 {
17974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17975 }
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj;
17984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17985 int arg2 ;
17986 PyObject * obj0 = 0 ;
17987 PyObject * obj1 = 0 ;
17988 char *kwnames[] = {
17989 (char *) "self",(char *) "m_wheelRotation", NULL
17990 };
17991
17992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17994 if (SWIG_arg_fail(1)) SWIG_fail;
17995 {
17996 arg2 = (int)(SWIG_As_int(obj1));
17997 if (SWIG_arg_fail(2)) SWIG_fail;
17998 }
17999 if (arg1) (arg1)->m_wheelRotation = arg2;
18000
18001 Py_INCREF(Py_None); resultobj = Py_None;
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18009 PyObject *resultobj;
18010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18011 int result;
18012 PyObject * obj0 = 0 ;
18013 char *kwnames[] = {
18014 (char *) "self", NULL
18015 };
18016
18017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18019 if (SWIG_arg_fail(1)) SWIG_fail;
18020 result = (int) ((arg1)->m_wheelRotation);
18021
18022 {
18023 resultobj = SWIG_From_int((int)(result));
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18034 int arg2 ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self",(char *) "m_wheelDelta", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 arg2 = (int)(SWIG_As_int(obj1));
18046 if (SWIG_arg_fail(2)) SWIG_fail;
18047 }
18048 if (arg1) (arg1)->m_wheelDelta = arg2;
18049
18050 Py_INCREF(Py_None); resultobj = Py_None;
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18058 PyObject *resultobj;
18059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18060 int result;
18061 PyObject * obj0 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 result = (int) ((arg1)->m_wheelDelta);
18070
18071 {
18072 resultobj = SWIG_From_int((int)(result));
18073 }
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj;
18082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18083 int arg2 ;
18084 PyObject * obj0 = 0 ;
18085 PyObject * obj1 = 0 ;
18086 char *kwnames[] = {
18087 (char *) "self",(char *) "m_linesPerAction", NULL
18088 };
18089
18090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18092 if (SWIG_arg_fail(1)) SWIG_fail;
18093 {
18094 arg2 = (int)(SWIG_As_int(obj1));
18095 if (SWIG_arg_fail(2)) SWIG_fail;
18096 }
18097 if (arg1) (arg1)->m_linesPerAction = arg2;
18098
18099 Py_INCREF(Py_None); resultobj = Py_None;
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18107 PyObject *resultobj;
18108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18109 int result;
18110 PyObject * obj0 = 0 ;
18111 char *kwnames[] = {
18112 (char *) "self", NULL
18113 };
18114
18115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18117 if (SWIG_arg_fail(1)) SWIG_fail;
18118 result = (int) ((arg1)->m_linesPerAction);
18119
18120 {
18121 resultobj = SWIG_From_int((int)(result));
18122 }
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18130 PyObject *obj;
18131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18132 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18133 Py_INCREF(obj);
18134 return Py_BuildValue((char *)"");
18135 }
18136 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj;
18138 int arg1 = (int) 0 ;
18139 int arg2 = (int) 0 ;
18140 wxSetCursorEvent *result;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char *kwnames[] = {
18144 (char *) "x",(char *) "y", NULL
18145 };
18146
18147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18148 if (obj0) {
18149 {
18150 arg1 = (int)(SWIG_As_int(obj0));
18151 if (SWIG_arg_fail(1)) SWIG_fail;
18152 }
18153 }
18154 if (obj1) {
18155 {
18156 arg2 = (int)(SWIG_As_int(obj1));
18157 if (SWIG_arg_fail(2)) SWIG_fail;
18158 }
18159 }
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18163
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj;
18176 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18177 int result;
18178 PyObject * obj0 = 0 ;
18179 char *kwnames[] = {
18180 (char *) "self", NULL
18181 };
18182
18183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18185 if (SWIG_arg_fail(1)) SWIG_fail;
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 {
18194 resultobj = SWIG_From_int((int)(result));
18195 }
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj;
18204 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18205 int result;
18206 PyObject * obj0 = 0 ;
18207 char *kwnames[] = {
18208 (char *) "self", NULL
18209 };
18210
18211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18213 if (SWIG_arg_fail(1)) SWIG_fail;
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 resultobj = SWIG_From_int((int)(result));
18223 }
18224 return resultobj;
18225 fail:
18226 return NULL;
18227 }
18228
18229
18230 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18231 PyObject *resultobj;
18232 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18233 wxCursor *arg2 = 0 ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self",(char *) "cursor", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 if (arg2 == NULL) {
18247 SWIG_null_ref("wxCursor");
18248 }
18249 if (SWIG_arg_fail(2)) SWIG_fail;
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 (arg1)->SetCursor((wxCursor const &)*arg2);
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 Py_INCREF(Py_None); resultobj = Py_None;
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18268 wxCursor *result;
18269 PyObject * obj0 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 {
18280 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18281 result = (wxCursor *) &_result_ref;
18282 }
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 {
18288 wxCursor* resultptr = new wxCursor(*result);
18289 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18290 }
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18300 bool result;
18301 PyObject * obj0 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18312
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18326 PyObject *obj;
18327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18328 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18329 Py_INCREF(obj);
18330 return Py_BuildValue((char *)"");
18331 }
18332 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18333 PyObject *resultobj;
18334 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18335 wxKeyEvent *result;
18336 PyObject * obj0 = 0 ;
18337 char *kwnames[] = {
18338 (char *) "eventType", NULL
18339 };
18340
18341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18342 if (obj0) {
18343 {
18344 arg1 = (wxEventType)(SWIG_As_int(obj0));
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 }
18347 }
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18351
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj;
18364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18365 bool result;
18366 PyObject * obj0 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18377
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj;
18392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18393 bool result;
18394 PyObject * obj0 = 0 ;
18395 char *kwnames[] = {
18396 (char *) "self", NULL
18397 };
18398
18399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18401 if (SWIG_arg_fail(1)) SWIG_fail;
18402 {
18403 PyThreadState* __tstate = wxPyBeginAllowThreads();
18404 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18405
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 {
18410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18411 }
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18421 bool result;
18422 PyObject * obj0 = 0 ;
18423 char *kwnames[] = {
18424 (char *) "self", NULL
18425 };
18426
18427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18429 if (SWIG_arg_fail(1)) SWIG_fail;
18430 {
18431 PyThreadState* __tstate = wxPyBeginAllowThreads();
18432 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18433
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj;
18448 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18449 bool result;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18461
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 {
18466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18467 }
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj;
18476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18477 bool result;
18478 PyObject * obj0 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 {
18494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18495 }
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18503 PyObject *resultobj;
18504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18505 bool result;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18533 int result;
18534 PyObject * obj0 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "self", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(1)) SWIG_fail;
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = SWIG_From_int((int)(result));
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18561 int result;
18562 PyObject * obj0 = 0 ;
18563 char *kwnames[] = {
18564 (char *) "self", NULL
18565 };
18566
18567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18569 if (SWIG_arg_fail(1)) SWIG_fail;
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18573
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 {
18578 resultobj = SWIG_From_int((int)(result));
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18589 unsigned int result;
18590 PyObject * obj0 = 0 ;
18591 char *kwnames[] = {
18592 (char *) "self", NULL
18593 };
18594
18595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18597 if (SWIG_arg_fail(1)) SWIG_fail;
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18601
18602 wxPyEndAllowThreads(__tstate);
18603 if (PyErr_Occurred()) SWIG_fail;
18604 }
18605 {
18606 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18607 }
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj;
18616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18617 unsigned int result;
18618 PyObject * obj0 = 0 ;
18619 char *kwnames[] = {
18620 (char *) "self", NULL
18621 };
18622
18623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18629
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18643 PyObject *resultobj;
18644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18645 wxPoint result;
18646 PyObject * obj0 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "self", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18653 if (SWIG_arg_fail(1)) SWIG_fail;
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (arg1)->GetPosition();
18657
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 {
18662 wxPoint * resultptr;
18663 resultptr = new wxPoint((wxPoint &)(result));
18664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18665 }
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18675 long *arg2 = (long *) 0 ;
18676 long *arg3 = (long *) 0 ;
18677 long temp2 ;
18678 int res2 = 0 ;
18679 long temp3 ;
18680 int res3 = 0 ;
18681 PyObject * obj0 = 0 ;
18682 char *kwnames[] = {
18683 (char *) "self", NULL
18684 };
18685
18686 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18687 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18690 if (SWIG_arg_fail(1)) SWIG_fail;
18691 {
18692 PyThreadState* __tstate = wxPyBeginAllowThreads();
18693 (arg1)->GetPosition(arg2,arg3);
18694
18695 wxPyEndAllowThreads(__tstate);
18696 if (PyErr_Occurred()) SWIG_fail;
18697 }
18698 Py_INCREF(Py_None); resultobj = Py_None;
18699 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18700 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18701 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18702 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18712 int result;
18713 PyObject * obj0 = 0 ;
18714 char *kwnames[] = {
18715 (char *) "self", NULL
18716 };
18717
18718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18720 if (SWIG_arg_fail(1)) SWIG_fail;
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = (int)((wxKeyEvent const *)arg1)->GetX();
18724
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 {
18729 resultobj = SWIG_From_int((int)(result));
18730 }
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18738 PyObject *resultobj;
18739 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18740 int result;
18741 PyObject * obj0 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (int)((wxKeyEvent const *)arg1)->GetY();
18752
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 {
18757 resultobj = SWIG_From_int((int)(result));
18758 }
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18766 PyObject *resultobj;
18767 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18768 int arg2 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char *kwnames[] = {
18772 (char *) "self",(char *) "m_x", NULL
18773 };
18774
18775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18777 if (SWIG_arg_fail(1)) SWIG_fail;
18778 {
18779 arg2 = (int)(SWIG_As_int(obj1));
18780 if (SWIG_arg_fail(2)) SWIG_fail;
18781 }
18782 if (arg1) (arg1)->m_x = arg2;
18783
18784 Py_INCREF(Py_None); resultobj = Py_None;
18785 return resultobj;
18786 fail:
18787 return NULL;
18788 }
18789
18790
18791 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18792 PyObject *resultobj;
18793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18794 int result;
18795 PyObject * obj0 = 0 ;
18796 char *kwnames[] = {
18797 (char *) "self", NULL
18798 };
18799
18800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18802 if (SWIG_arg_fail(1)) SWIG_fail;
18803 result = (int) ((arg1)->m_x);
18804
18805 {
18806 resultobj = SWIG_From_int((int)(result));
18807 }
18808 return resultobj;
18809 fail:
18810 return NULL;
18811 }
18812
18813
18814 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj;
18816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18817 int arg2 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "self",(char *) "m_y", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18826 if (SWIG_arg_fail(1)) SWIG_fail;
18827 {
18828 arg2 = (int)(SWIG_As_int(obj1));
18829 if (SWIG_arg_fail(2)) SWIG_fail;
18830 }
18831 if (arg1) (arg1)->m_y = arg2;
18832
18833 Py_INCREF(Py_None); resultobj = Py_None;
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj;
18842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18843 int result;
18844 PyObject * obj0 = 0 ;
18845 char *kwnames[] = {
18846 (char *) "self", NULL
18847 };
18848
18849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18851 if (SWIG_arg_fail(1)) SWIG_fail;
18852 result = (int) ((arg1)->m_y);
18853
18854 {
18855 resultobj = SWIG_From_int((int)(result));
18856 }
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj;
18865 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18866 long arg2 ;
18867 PyObject * obj0 = 0 ;
18868 PyObject * obj1 = 0 ;
18869 char *kwnames[] = {
18870 (char *) "self",(char *) "m_keyCode", NULL
18871 };
18872
18873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18875 if (SWIG_arg_fail(1)) SWIG_fail;
18876 {
18877 arg2 = (long)(SWIG_As_long(obj1));
18878 if (SWIG_arg_fail(2)) SWIG_fail;
18879 }
18880 if (arg1) (arg1)->m_keyCode = arg2;
18881
18882 Py_INCREF(Py_None); resultobj = Py_None;
18883 return resultobj;
18884 fail:
18885 return NULL;
18886 }
18887
18888
18889 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj;
18891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18892 long result;
18893 PyObject * obj0 = 0 ;
18894 char *kwnames[] = {
18895 (char *) "self", NULL
18896 };
18897
18898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18900 if (SWIG_arg_fail(1)) SWIG_fail;
18901 result = (long) ((arg1)->m_keyCode);
18902
18903 {
18904 resultobj = SWIG_From_long((long)(result));
18905 }
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj;
18914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18915 bool arg2 ;
18916 PyObject * obj0 = 0 ;
18917 PyObject * obj1 = 0 ;
18918 char *kwnames[] = {
18919 (char *) "self",(char *) "m_controlDown", NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18924 if (SWIG_arg_fail(1)) SWIG_fail;
18925 {
18926 arg2 = (bool)(SWIG_As_bool(obj1));
18927 if (SWIG_arg_fail(2)) SWIG_fail;
18928 }
18929 if (arg1) (arg1)->m_controlDown = arg2;
18930
18931 Py_INCREF(Py_None); resultobj = Py_None;
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18939 PyObject *resultobj;
18940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18941 bool result;
18942 PyObject * obj0 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "self", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 result = (bool) ((arg1)->m_controlDown);
18951
18952 {
18953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18954 }
18955 return resultobj;
18956 fail:
18957 return NULL;
18958 }
18959
18960
18961 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18962 PyObject *resultobj;
18963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18964 bool arg2 ;
18965 PyObject * obj0 = 0 ;
18966 PyObject * obj1 = 0 ;
18967 char *kwnames[] = {
18968 (char *) "self",(char *) "m_shiftDown", NULL
18969 };
18970
18971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18973 if (SWIG_arg_fail(1)) SWIG_fail;
18974 {
18975 arg2 = (bool)(SWIG_As_bool(obj1));
18976 if (SWIG_arg_fail(2)) SWIG_fail;
18977 }
18978 if (arg1) (arg1)->m_shiftDown = arg2;
18979
18980 Py_INCREF(Py_None); resultobj = Py_None;
18981 return resultobj;
18982 fail:
18983 return NULL;
18984 }
18985
18986
18987 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18988 PyObject *resultobj;
18989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18990 bool result;
18991 PyObject * obj0 = 0 ;
18992 char *kwnames[] = {
18993 (char *) "self", NULL
18994 };
18995
18996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18998 if (SWIG_arg_fail(1)) SWIG_fail;
18999 result = (bool) ((arg1)->m_shiftDown);
19000
19001 {
19002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19003 }
19004 return resultobj;
19005 fail:
19006 return NULL;
19007 }
19008
19009
19010 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19011 PyObject *resultobj;
19012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19013 bool arg2 ;
19014 PyObject * obj0 = 0 ;
19015 PyObject * obj1 = 0 ;
19016 char *kwnames[] = {
19017 (char *) "self",(char *) "m_altDown", NULL
19018 };
19019
19020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19022 if (SWIG_arg_fail(1)) SWIG_fail;
19023 {
19024 arg2 = (bool)(SWIG_As_bool(obj1));
19025 if (SWIG_arg_fail(2)) SWIG_fail;
19026 }
19027 if (arg1) (arg1)->m_altDown = arg2;
19028
19029 Py_INCREF(Py_None); resultobj = Py_None;
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19037 PyObject *resultobj;
19038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19039 bool result;
19040 PyObject * obj0 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "self", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19047 if (SWIG_arg_fail(1)) SWIG_fail;
19048 result = (bool) ((arg1)->m_altDown);
19049
19050 {
19051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19052 }
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj;
19061 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19062 bool arg2 ;
19063 PyObject * obj0 = 0 ;
19064 PyObject * obj1 = 0 ;
19065 char *kwnames[] = {
19066 (char *) "self",(char *) "m_metaDown", NULL
19067 };
19068
19069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19071 if (SWIG_arg_fail(1)) SWIG_fail;
19072 {
19073 arg2 = (bool)(SWIG_As_bool(obj1));
19074 if (SWIG_arg_fail(2)) SWIG_fail;
19075 }
19076 if (arg1) (arg1)->m_metaDown = arg2;
19077
19078 Py_INCREF(Py_None); resultobj = Py_None;
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19088 bool result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "self", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19096 if (SWIG_arg_fail(1)) SWIG_fail;
19097 result = (bool) ((arg1)->m_metaDown);
19098
19099 {
19100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19101 }
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19109 PyObject *resultobj;
19110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19111 bool arg2 ;
19112 PyObject * obj0 = 0 ;
19113 PyObject * obj1 = 0 ;
19114 char *kwnames[] = {
19115 (char *) "self",(char *) "m_scanCode", NULL
19116 };
19117
19118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19120 if (SWIG_arg_fail(1)) SWIG_fail;
19121 {
19122 arg2 = (bool)(SWIG_As_bool(obj1));
19123 if (SWIG_arg_fail(2)) SWIG_fail;
19124 }
19125 if (arg1) (arg1)->m_scanCode = arg2;
19126
19127 Py_INCREF(Py_None); resultobj = Py_None;
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19135 PyObject *resultobj;
19136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19137 bool result;
19138 PyObject * obj0 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "self", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19145 if (SWIG_arg_fail(1)) SWIG_fail;
19146 result = (bool) ((arg1)->m_scanCode);
19147
19148 {
19149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19150 }
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj;
19159 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19160 unsigned int arg2 ;
19161 PyObject * obj0 = 0 ;
19162 PyObject * obj1 = 0 ;
19163 char *kwnames[] = {
19164 (char *) "self",(char *) "m_rawCode", NULL
19165 };
19166
19167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19169 if (SWIG_arg_fail(1)) SWIG_fail;
19170 {
19171 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19172 if (SWIG_arg_fail(2)) SWIG_fail;
19173 }
19174 if (arg1) (arg1)->m_rawCode = arg2;
19175
19176 Py_INCREF(Py_None); resultobj = Py_None;
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19184 PyObject *resultobj;
19185 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19186 unsigned int result;
19187 PyObject * obj0 = 0 ;
19188 char *kwnames[] = {
19189 (char *) "self", NULL
19190 };
19191
19192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19194 if (SWIG_arg_fail(1)) SWIG_fail;
19195 result = (unsigned int) ((arg1)->m_rawCode);
19196
19197 {
19198 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19199 }
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj;
19208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19209 unsigned int arg2 ;
19210 PyObject * obj0 = 0 ;
19211 PyObject * obj1 = 0 ;
19212 char *kwnames[] = {
19213 (char *) "self",(char *) "m_rawFlags", NULL
19214 };
19215
19216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19218 if (SWIG_arg_fail(1)) SWIG_fail;
19219 {
19220 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19221 if (SWIG_arg_fail(2)) SWIG_fail;
19222 }
19223 if (arg1) (arg1)->m_rawFlags = arg2;
19224
19225 Py_INCREF(Py_None); resultobj = Py_None;
19226 return resultobj;
19227 fail:
19228 return NULL;
19229 }
19230
19231
19232 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj;
19234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19235 unsigned int result;
19236 PyObject * obj0 = 0 ;
19237 char *kwnames[] = {
19238 (char *) "self", NULL
19239 };
19240
19241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19243 if (SWIG_arg_fail(1)) SWIG_fail;
19244 result = (unsigned int) ((arg1)->m_rawFlags);
19245
19246 {
19247 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19256 PyObject *obj;
19257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19258 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19259 Py_INCREF(obj);
19260 return Py_BuildValue((char *)"");
19261 }
19262 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19263 PyObject *resultobj;
19264 wxSize const &arg1_defvalue = wxDefaultSize ;
19265 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19266 int arg2 = (int) 0 ;
19267 wxSizeEvent *result;
19268 wxSize temp1 ;
19269 PyObject * obj0 = 0 ;
19270 PyObject * obj1 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "sz",(char *) "winid", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19276 if (obj0) {
19277 {
19278 arg1 = &temp1;
19279 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19280 }
19281 }
19282 if (obj1) {
19283 {
19284 arg2 = (int)(SWIG_As_int(obj1));
19285 if (SWIG_arg_fail(2)) SWIG_fail;
19286 }
19287 }
19288 {
19289 PyThreadState* __tstate = wxPyBeginAllowThreads();
19290 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19291
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19305 wxSize result;
19306 PyObject * obj0 = 0 ;
19307 char *kwnames[] = {
19308 (char *) "self", NULL
19309 };
19310
19311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19313 if (SWIG_arg_fail(1)) SWIG_fail;
19314 {
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = ((wxSizeEvent const *)arg1)->GetSize();
19317
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 {
19322 wxSize * resultptr;
19323 resultptr = new wxSize((wxSize &)(result));
19324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19325 }
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj;
19334 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19335 wxRect result;
19336 PyObject * obj0 = 0 ;
19337 char *kwnames[] = {
19338 (char *) "self", NULL
19339 };
19340
19341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19343 if (SWIG_arg_fail(1)) SWIG_fail;
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = ((wxSizeEvent const *)arg1)->GetRect();
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 {
19352 wxRect * resultptr;
19353 resultptr = new wxRect((wxRect &)(result));
19354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19365 wxRect arg2 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self",(char *) "rect", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 {
19376 wxRect * argp;
19377 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19378 if (SWIG_arg_fail(2)) SWIG_fail;
19379 if (argp == NULL) {
19380 SWIG_null_ref("wxRect");
19381 }
19382 if (SWIG_arg_fail(2)) SWIG_fail;
19383 arg2 = *argp;
19384 }
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->SetRect(arg2);
19388
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 Py_INCREF(Py_None); resultobj = Py_None;
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19400 PyObject *resultobj;
19401 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19402 wxSize arg2 ;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "self",(char *) "size", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19411 if (SWIG_arg_fail(1)) SWIG_fail;
19412 {
19413 wxSize * argp;
19414 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19415 if (SWIG_arg_fail(2)) SWIG_fail;
19416 if (argp == NULL) {
19417 SWIG_null_ref("wxSize");
19418 }
19419 if (SWIG_arg_fail(2)) SWIG_fail;
19420 arg2 = *argp;
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 wxSizeEvent_SetSize(arg1,arg2);
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 Py_INCREF(Py_None); resultobj = Py_None;
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19439 wxSize *arg2 = (wxSize *) 0 ;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "self",(char *) "m_size", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19450 if (SWIG_arg_fail(2)) SWIG_fail;
19451 if (arg1) (arg1)->m_size = *arg2;
19452
19453 Py_INCREF(Py_None); resultobj = Py_None;
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj;
19462 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19463 wxSize *result;
19464 PyObject * obj0 = 0 ;
19465 char *kwnames[] = {
19466 (char *) "self", NULL
19467 };
19468
19469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19471 if (SWIG_arg_fail(1)) SWIG_fail;
19472 result = (wxSize *)& ((arg1)->m_size);
19473
19474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj;
19483 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19484 wxRect *arg2 = (wxRect *) 0 ;
19485 PyObject * obj0 = 0 ;
19486 PyObject * obj1 = 0 ;
19487 char *kwnames[] = {
19488 (char *) "self",(char *) "m_rect", NULL
19489 };
19490
19491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19493 if (SWIG_arg_fail(1)) SWIG_fail;
19494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19495 if (SWIG_arg_fail(2)) SWIG_fail;
19496 if (arg1) (arg1)->m_rect = *arg2;
19497
19498 Py_INCREF(Py_None); resultobj = Py_None;
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19506 PyObject *resultobj;
19507 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19508 wxRect *result;
19509 PyObject * obj0 = 0 ;
19510 char *kwnames[] = {
19511 (char *) "self", NULL
19512 };
19513
19514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19516 if (SWIG_arg_fail(1)) SWIG_fail;
19517 result = (wxRect *)& ((arg1)->m_rect);
19518
19519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19527 PyObject *obj;
19528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19529 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19530 Py_INCREF(obj);
19531 return Py_BuildValue((char *)"");
19532 }
19533 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj;
19535 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19536 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19537 int arg2 = (int) 0 ;
19538 wxMoveEvent *result;
19539 wxPoint temp1 ;
19540 PyObject * obj0 = 0 ;
19541 PyObject * obj1 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "pos",(char *) "winid", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19547 if (obj0) {
19548 {
19549 arg1 = &temp1;
19550 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19551 }
19552 }
19553 if (obj1) {
19554 {
19555 arg2 = (int)(SWIG_As_int(obj1));
19556 if (SWIG_arg_fail(2)) SWIG_fail;
19557 }
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj;
19575 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19576 wxPoint result;
19577 PyObject * obj0 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = ((wxMoveEvent const *)arg1)->GetPosition();
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 wxPoint * resultptr;
19594 resultptr = new wxPoint((wxPoint &)(result));
19595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj;
19605 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19606 wxRect result;
19607 PyObject * obj0 = 0 ;
19608 char *kwnames[] = {
19609 (char *) "self", NULL
19610 };
19611
19612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19614 if (SWIG_arg_fail(1)) SWIG_fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = ((wxMoveEvent const *)arg1)->GetRect();
19618
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 {
19623 wxRect * resultptr;
19624 resultptr = new wxRect((wxRect &)(result));
19625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19626 }
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19636 wxRect *arg2 = 0 ;
19637 wxRect temp2 ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "self",(char *) "rect", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 {
19648 arg2 = &temp2;
19649 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19650 }
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetRect((wxRect const &)*arg2);
19654
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 Py_INCREF(Py_None); resultobj = Py_None;
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj;
19667 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19668 wxPoint *arg2 = 0 ;
19669 wxPoint temp2 ;
19670 PyObject * obj0 = 0 ;
19671 PyObject * obj1 = 0 ;
19672 char *kwnames[] = {
19673 (char *) "self",(char *) "pos", NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 {
19680 arg2 = &temp2;
19681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 (arg1)->SetPosition((wxPoint const &)*arg2);
19686
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 Py_INCREF(Py_None); resultobj = Py_None;
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19698 PyObject *obj;
19699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19700 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19701 Py_INCREF(obj);
19702 return Py_BuildValue((char *)"");
19703 }
19704 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj;
19706 int arg1 = (int) 0 ;
19707 wxPaintEvent *result;
19708 PyObject * obj0 = 0 ;
19709 char *kwnames[] = {
19710 (char *) "Id", NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19714 if (obj0) {
19715 {
19716 arg1 = (int)(SWIG_As_int(obj0));
19717 if (SWIG_arg_fail(1)) SWIG_fail;
19718 }
19719 }
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19723
19724 wxPyEndAllowThreads(__tstate);
19725 if (PyErr_Occurred()) SWIG_fail;
19726 }
19727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19735 PyObject *obj;
19736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19737 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19738 Py_INCREF(obj);
19739 return Py_BuildValue((char *)"");
19740 }
19741 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 int arg1 = (int) 0 ;
19744 wxNcPaintEvent *result;
19745 PyObject * obj0 = 0 ;
19746 char *kwnames[] = {
19747 (char *) "winid", NULL
19748 };
19749
19750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19751 if (obj0) {
19752 {
19753 arg1 = (int)(SWIG_As_int(obj0));
19754 if (SWIG_arg_fail(1)) SWIG_fail;
19755 }
19756 }
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19760
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19772 PyObject *obj;
19773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19774 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19775 Py_INCREF(obj);
19776 return Py_BuildValue((char *)"");
19777 }
19778 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19779 PyObject *resultobj;
19780 int arg1 = (int) 0 ;
19781 wxDC *arg2 = (wxDC *) NULL ;
19782 wxEraseEvent *result;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 char *kwnames[] = {
19786 (char *) "Id",(char *) "dc", NULL
19787 };
19788
19789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19790 if (obj0) {
19791 {
19792 arg1 = (int)(SWIG_As_int(obj0));
19793 if (SWIG_arg_fail(1)) SWIG_fail;
19794 }
19795 }
19796 if (obj1) {
19797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(2)) SWIG_fail;
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19803
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj;
19816 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19817 wxDC *result;
19818 PyObject * obj0 = 0 ;
19819 char *kwnames[] = {
19820 (char *) "self", NULL
19821 };
19822
19823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19825 if (SWIG_arg_fail(1)) SWIG_fail;
19826 {
19827 PyThreadState* __tstate = wxPyBeginAllowThreads();
19828 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19829
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = wxPyMake_wxObject(result, 0);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19843 PyObject *obj;
19844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19845 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19846 Py_INCREF(obj);
19847 return Py_BuildValue((char *)"");
19848 }
19849 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19852 int arg2 = (int) 0 ;
19853 wxFocusEvent *result;
19854 PyObject * obj0 = 0 ;
19855 PyObject * obj1 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "type",(char *) "winid", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19861 if (obj0) {
19862 {
19863 arg1 = (wxEventType)(SWIG_As_int(obj0));
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 }
19866 }
19867 if (obj1) {
19868 {
19869 arg2 = (int)(SWIG_As_int(obj1));
19870 if (SWIG_arg_fail(2)) SWIG_fail;
19871 }
19872 }
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19876
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj;
19889 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19890 wxWindow *result;
19891 PyObject * obj0 = 0 ;
19892 char *kwnames[] = {
19893 (char *) "self", NULL
19894 };
19895
19896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19898 if (SWIG_arg_fail(1)) SWIG_fail;
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19902
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 {
19907 resultobj = wxPyMake_wxObject(result, 0);
19908 }
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj;
19917 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19918 wxWindow *arg2 = (wxWindow *) 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char *kwnames[] = {
19922 (char *) "self",(char *) "win", NULL
19923 };
19924
19925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19927 if (SWIG_arg_fail(1)) SWIG_fail;
19928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(2)) SWIG_fail;
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 (arg1)->SetWindow(arg2);
19933
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 Py_INCREF(Py_None); resultobj = Py_None;
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19945 PyObject *obj;
19946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19947 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19948 Py_INCREF(obj);
19949 return Py_BuildValue((char *)"");
19950 }
19951 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj;
19953 wxWindow *arg1 = (wxWindow *) NULL ;
19954 wxChildFocusEvent *result;
19955 PyObject * obj0 = 0 ;
19956 char *kwnames[] = {
19957 (char *) "win", NULL
19958 };
19959
19960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19961 if (obj0) {
19962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19963 if (SWIG_arg_fail(1)) SWIG_fail;
19964 }
19965 {
19966 PyThreadState* __tstate = wxPyBeginAllowThreads();
19967 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19968
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj;
19981 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19982 wxWindow *result;
19983 PyObject * obj0 = 0 ;
19984 char *kwnames[] = {
19985 (char *) "self", NULL
19986 };
19987
19988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19990 if (SWIG_arg_fail(1)) SWIG_fail;
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19994
19995 wxPyEndAllowThreads(__tstate);
19996 if (PyErr_Occurred()) SWIG_fail;
19997 }
19998 {
19999 resultobj = wxPyMake_wxObject(result, 0);
20000 }
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20008 PyObject *obj;
20009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20010 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20011 Py_INCREF(obj);
20012 return Py_BuildValue((char *)"");
20013 }
20014 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20015 PyObject *resultobj;
20016 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20017 bool arg2 = (bool) true ;
20018 int arg3 = (int) 0 ;
20019 wxActivateEvent *result;
20020 PyObject * obj0 = 0 ;
20021 PyObject * obj1 = 0 ;
20022 PyObject * obj2 = 0 ;
20023 char *kwnames[] = {
20024 (char *) "type",(char *) "active",(char *) "Id", NULL
20025 };
20026
20027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20028 if (obj0) {
20029 {
20030 arg1 = (wxEventType)(SWIG_As_int(obj0));
20031 if (SWIG_arg_fail(1)) SWIG_fail;
20032 }
20033 }
20034 if (obj1) {
20035 {
20036 arg2 = (bool)(SWIG_As_bool(obj1));
20037 if (SWIG_arg_fail(2)) SWIG_fail;
20038 }
20039 }
20040 if (obj2) {
20041 {
20042 arg3 = (int)(SWIG_As_int(obj2));
20043 if (SWIG_arg_fail(3)) SWIG_fail;
20044 }
20045 }
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20061 PyObject *resultobj;
20062 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20063 bool result;
20064 PyObject * obj0 = 0 ;
20065 char *kwnames[] = {
20066 (char *) "self", NULL
20067 };
20068
20069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20071 if (SWIG_arg_fail(1)) SWIG_fail;
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20075
20076 wxPyEndAllowThreads(__tstate);
20077 if (PyErr_Occurred()) SWIG_fail;
20078 }
20079 {
20080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20081 }
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20089 PyObject *obj;
20090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20091 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20092 Py_INCREF(obj);
20093 return Py_BuildValue((char *)"");
20094 }
20095 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 int arg1 = (int) 0 ;
20098 wxInitDialogEvent *result;
20099 PyObject * obj0 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "Id", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20105 if (obj0) {
20106 {
20107 arg1 = (int)(SWIG_As_int(obj0));
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 }
20110 }
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20114
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20119 return resultobj;
20120 fail:
20121 return NULL;
20122 }
20123
20124
20125 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20126 PyObject *obj;
20127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20128 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20129 Py_INCREF(obj);
20130 return Py_BuildValue((char *)"");
20131 }
20132 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20135 int arg2 = (int) 0 ;
20136 wxMenu *arg3 = (wxMenu *) NULL ;
20137 wxMenuEvent *result;
20138 PyObject * obj0 = 0 ;
20139 PyObject * obj1 = 0 ;
20140 PyObject * obj2 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "type",(char *) "winid",(char *) "menu", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20146 if (obj0) {
20147 {
20148 arg1 = (wxEventType)(SWIG_As_int(obj0));
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 }
20151 }
20152 if (obj1) {
20153 {
20154 arg2 = (int)(SWIG_As_int(obj1));
20155 if (SWIG_arg_fail(2)) SWIG_fail;
20156 }
20157 }
20158 if (obj2) {
20159 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(3)) SWIG_fail;
20161 }
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20179 int result;
20180 PyObject * obj0 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "self", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20187 if (SWIG_arg_fail(1)) SWIG_fail;
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20191
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = SWIG_From_int((int)(result));
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20207 bool result;
20208 PyObject * obj0 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 {
20224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20225 }
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj;
20234 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20235 wxMenu *result;
20236 PyObject * obj0 = 0 ;
20237 char *kwnames[] = {
20238 (char *) "self", NULL
20239 };
20240
20241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20243 if (SWIG_arg_fail(1)) SWIG_fail;
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20247
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 {
20252 resultobj = wxPyMake_wxObject(result, 0);
20253 }
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20261 PyObject *obj;
20262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20263 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20264 Py_INCREF(obj);
20265 return Py_BuildValue((char *)"");
20266 }
20267 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj;
20269 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20270 int arg2 = (int) 0 ;
20271 wxCloseEvent *result;
20272 PyObject * obj0 = 0 ;
20273 PyObject * obj1 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "type",(char *) "winid", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20279 if (obj0) {
20280 {
20281 arg1 = (wxEventType)(SWIG_As_int(obj0));
20282 if (SWIG_arg_fail(1)) SWIG_fail;
20283 }
20284 }
20285 if (obj1) {
20286 {
20287 arg2 = (int)(SWIG_As_int(obj1));
20288 if (SWIG_arg_fail(2)) SWIG_fail;
20289 }
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20306 PyObject *resultobj;
20307 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20308 bool arg2 ;
20309 PyObject * obj0 = 0 ;
20310 PyObject * obj1 = 0 ;
20311 char *kwnames[] = {
20312 (char *) "self",(char *) "logOff", NULL
20313 };
20314
20315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20317 if (SWIG_arg_fail(1)) SWIG_fail;
20318 {
20319 arg2 = (bool)(SWIG_As_bool(obj1));
20320 if (SWIG_arg_fail(2)) SWIG_fail;
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 (arg1)->SetLoggingOff(arg2);
20325
20326 wxPyEndAllowThreads(__tstate);
20327 if (PyErr_Occurred()) SWIG_fail;
20328 }
20329 Py_INCREF(Py_None); resultobj = Py_None;
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj;
20338 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20339 bool result;
20340 PyObject * obj0 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 {
20356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20357 }
20358 return resultobj;
20359 fail:
20360 return NULL;
20361 }
20362
20363
20364 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20367 bool arg2 = (bool) true ;
20368 PyObject * obj0 = 0 ;
20369 PyObject * obj1 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self",(char *) "veto", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 if (obj1) {
20378 {
20379 arg2 = (bool)(SWIG_As_bool(obj1));
20380 if (SWIG_arg_fail(2)) SWIG_fail;
20381 }
20382 }
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 (arg1)->Veto(arg2);
20386
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 Py_INCREF(Py_None); resultobj = Py_None;
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20398 PyObject *resultobj;
20399 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20400 bool result;
20401 PyObject * obj0 = 0 ;
20402 char *kwnames[] = {
20403 (char *) "self", NULL
20404 };
20405
20406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20408 if (SWIG_arg_fail(1)) SWIG_fail;
20409 {
20410 PyThreadState* __tstate = wxPyBeginAllowThreads();
20411 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20418 }
20419 return resultobj;
20420 fail:
20421 return NULL;
20422 }
20423
20424
20425 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj;
20427 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20428 bool arg2 ;
20429 PyObject * obj0 = 0 ;
20430 PyObject * obj1 = 0 ;
20431 char *kwnames[] = {
20432 (char *) "self",(char *) "canVeto", NULL
20433 };
20434
20435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20437 if (SWIG_arg_fail(1)) SWIG_fail;
20438 {
20439 arg2 = (bool)(SWIG_As_bool(obj1));
20440 if (SWIG_arg_fail(2)) SWIG_fail;
20441 }
20442 {
20443 PyThreadState* __tstate = wxPyBeginAllowThreads();
20444 (arg1)->SetCanVeto(arg2);
20445
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 Py_INCREF(Py_None); resultobj = Py_None;
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20457 PyObject *resultobj;
20458 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20459 bool result;
20460 PyObject * obj0 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20471
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 {
20476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20477 }
20478 return resultobj;
20479 fail:
20480 return NULL;
20481 }
20482
20483
20484 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20485 PyObject *obj;
20486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20487 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20488 Py_INCREF(obj);
20489 return Py_BuildValue((char *)"");
20490 }
20491 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 int arg1 = (int) 0 ;
20494 bool arg2 = (bool) false ;
20495 wxShowEvent *result;
20496 PyObject * obj0 = 0 ;
20497 PyObject * obj1 = 0 ;
20498 char *kwnames[] = {
20499 (char *) "winid",(char *) "show", NULL
20500 };
20501
20502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20503 if (obj0) {
20504 {
20505 arg1 = (int)(SWIG_As_int(obj0));
20506 if (SWIG_arg_fail(1)) SWIG_fail;
20507 }
20508 }
20509 if (obj1) {
20510 {
20511 arg2 = (bool)(SWIG_As_bool(obj1));
20512 if (SWIG_arg_fail(2)) SWIG_fail;
20513 }
20514 }
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20518
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20523 return resultobj;
20524 fail:
20525 return NULL;
20526 }
20527
20528
20529 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj;
20531 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20532 bool arg2 ;
20533 PyObject * obj0 = 0 ;
20534 PyObject * obj1 = 0 ;
20535 char *kwnames[] = {
20536 (char *) "self",(char *) "show", NULL
20537 };
20538
20539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20541 if (SWIG_arg_fail(1)) SWIG_fail;
20542 {
20543 arg2 = (bool)(SWIG_As_bool(obj1));
20544 if (SWIG_arg_fail(2)) SWIG_fail;
20545 }
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 (arg1)->SetShow(arg2);
20549
20550 wxPyEndAllowThreads(__tstate);
20551 if (PyErr_Occurred()) SWIG_fail;
20552 }
20553 Py_INCREF(Py_None); resultobj = Py_None;
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20561 PyObject *resultobj;
20562 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20563 bool result;
20564 PyObject * obj0 = 0 ;
20565 char *kwnames[] = {
20566 (char *) "self", NULL
20567 };
20568
20569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20571 if (SWIG_arg_fail(1)) SWIG_fail;
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20575
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20589 PyObject *obj;
20590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20591 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20592 Py_INCREF(obj);
20593 return Py_BuildValue((char *)"");
20594 }
20595 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj;
20597 int arg1 = (int) 0 ;
20598 bool arg2 = (bool) true ;
20599 wxIconizeEvent *result;
20600 PyObject * obj0 = 0 ;
20601 PyObject * obj1 = 0 ;
20602 char *kwnames[] = {
20603 (char *) "id",(char *) "iconized", NULL
20604 };
20605
20606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20607 if (obj0) {
20608 {
20609 arg1 = (int)(SWIG_As_int(obj0));
20610 if (SWIG_arg_fail(1)) SWIG_fail;
20611 }
20612 }
20613 if (obj1) {
20614 {
20615 arg2 = (bool)(SWIG_As_bool(obj1));
20616 if (SWIG_arg_fail(2)) SWIG_fail;
20617 }
20618 }
20619 {
20620 PyThreadState* __tstate = wxPyBeginAllowThreads();
20621 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20622
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj;
20635 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20636 bool result;
20637 PyObject * obj0 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "self", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20644 if (SWIG_arg_fail(1)) SWIG_fail;
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (bool)(arg1)->Iconized();
20648
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 {
20653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20654 }
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20662 PyObject *obj;
20663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20664 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20665 Py_INCREF(obj);
20666 return Py_BuildValue((char *)"");
20667 }
20668 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj;
20670 int arg1 = (int) 0 ;
20671 wxMaximizeEvent *result;
20672 PyObject * obj0 = 0 ;
20673 char *kwnames[] = {
20674 (char *) "id", NULL
20675 };
20676
20677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20678 if (obj0) {
20679 {
20680 arg1 = (int)(SWIG_As_int(obj0));
20681 if (SWIG_arg_fail(1)) SWIG_fail;
20682 }
20683 }
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20687
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20699 PyObject *obj;
20700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20701 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20702 Py_INCREF(obj);
20703 return Py_BuildValue((char *)"");
20704 }
20705 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20706 PyObject *resultobj;
20707 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20708 wxPoint result;
20709 PyObject * obj0 = 0 ;
20710 char *kwnames[] = {
20711 (char *) "self", NULL
20712 };
20713
20714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20716 if (SWIG_arg_fail(1)) SWIG_fail;
20717 {
20718 PyThreadState* __tstate = wxPyBeginAllowThreads();
20719 result = (arg1)->GetPosition();
20720
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 wxPoint * resultptr;
20726 resultptr = new wxPoint((wxPoint &)(result));
20727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20738 int result;
20739 PyObject * obj0 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (int)(arg1)->GetNumberOfFiles();
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 {
20755 resultobj = SWIG_From_int((int)(result));
20756 }
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20764 PyObject *resultobj;
20765 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20766 PyObject *result;
20767 PyObject * obj0 = 0 ;
20768 char *kwnames[] = {
20769 (char *) "self", NULL
20770 };
20771
20772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20774 if (SWIG_arg_fail(1)) SWIG_fail;
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20778
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 resultobj = result;
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20790 PyObject *obj;
20791 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20792 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20793 Py_INCREF(obj);
20794 return Py_BuildValue((char *)"");
20795 }
20796 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20797 PyObject *resultobj;
20798 int arg1 = (int) 0 ;
20799 wxUpdateUIEvent *result;
20800 PyObject * obj0 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "commandId", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20806 if (obj0) {
20807 {
20808 arg1 = (int)(SWIG_As_int(obj0));
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 }
20811 }
20812 {
20813 PyThreadState* __tstate = wxPyBeginAllowThreads();
20814 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20815
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20829 bool result;
20830 PyObject * obj0 = 0 ;
20831 char *kwnames[] = {
20832 (char *) "self", NULL
20833 };
20834
20835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20837 if (SWIG_arg_fail(1)) SWIG_fail;
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20855 PyObject *resultobj;
20856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20857 bool result;
20858 PyObject * obj0 = 0 ;
20859 char *kwnames[] = {
20860 (char *) "self", NULL
20861 };
20862
20863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20865 if (SWIG_arg_fail(1)) SWIG_fail;
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20869
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20875 }
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj;
20884 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20885 wxString result;
20886 PyObject * obj0 = 0 ;
20887 char *kwnames[] = {
20888 (char *) "self", NULL
20889 };
20890
20891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20893 if (SWIG_arg_fail(1)) SWIG_fail;
20894 {
20895 PyThreadState* __tstate = wxPyBeginAllowThreads();
20896 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20897
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 #if wxUSE_UNICODE
20903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20904 #else
20905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20906 #endif
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20917 bool result;
20918 PyObject * obj0 = 0 ;
20919 char *kwnames[] = {
20920 (char *) "self", NULL
20921 };
20922
20923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20925 if (SWIG_arg_fail(1)) SWIG_fail;
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 {
20934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20935 }
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj;
20944 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20945 bool result;
20946 PyObject * obj0 = 0 ;
20947 char *kwnames[] = {
20948 (char *) "self", NULL
20949 };
20950
20951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20953 if (SWIG_arg_fail(1)) SWIG_fail;
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20957
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20973 bool result;
20974 PyObject * obj0 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20991 }
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj;
21000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21001 bool arg2 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 char *kwnames[] = {
21005 (char *) "self",(char *) "check", NULL
21006 };
21007
21008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21010 if (SWIG_arg_fail(1)) SWIG_fail;
21011 {
21012 arg2 = (bool)(SWIG_As_bool(obj1));
21013 if (SWIG_arg_fail(2)) SWIG_fail;
21014 }
21015 {
21016 PyThreadState* __tstate = wxPyBeginAllowThreads();
21017 (arg1)->Check(arg2);
21018
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 Py_INCREF(Py_None); resultobj = Py_None;
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21032 bool arg2 ;
21033 PyObject * obj0 = 0 ;
21034 PyObject * obj1 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self",(char *) "enable", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 arg2 = (bool)(SWIG_As_bool(obj1));
21044 if (SWIG_arg_fail(2)) SWIG_fail;
21045 }
21046 {
21047 PyThreadState* __tstate = wxPyBeginAllowThreads();
21048 (arg1)->Enable(arg2);
21049
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 Py_INCREF(Py_None); resultobj = Py_None;
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21063 wxString *arg2 = 0 ;
21064 bool temp2 = false ;
21065 PyObject * obj0 = 0 ;
21066 PyObject * obj1 = 0 ;
21067 char *kwnames[] = {
21068 (char *) "self",(char *) "text", NULL
21069 };
21070
21071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21073 if (SWIG_arg_fail(1)) SWIG_fail;
21074 {
21075 arg2 = wxString_in_helper(obj1);
21076 if (arg2 == NULL) SWIG_fail;
21077 temp2 = true;
21078 }
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 (arg1)->SetText((wxString const &)*arg2);
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 Py_INCREF(Py_None); resultobj = Py_None;
21087 {
21088 if (temp2)
21089 delete arg2;
21090 }
21091 return resultobj;
21092 fail:
21093 {
21094 if (temp2)
21095 delete arg2;
21096 }
21097 return NULL;
21098 }
21099
21100
21101 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21102 PyObject *resultobj;
21103 long arg1 ;
21104 PyObject * obj0 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "updateInterval", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21110 {
21111 arg1 = (long)(SWIG_As_long(obj0));
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 }
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 wxUpdateUIEvent::SetUpdateInterval(arg1);
21117
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 Py_INCREF(Py_None); resultobj = Py_None;
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj;
21130 long result;
21131 char *kwnames[] = {
21132 NULL
21133 };
21134
21135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = SWIG_From_long((long)(result));
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21153 PyObject *resultobj;
21154 wxWindow *arg1 = (wxWindow *) 0 ;
21155 bool result;
21156 PyObject * obj0 = 0 ;
21157 char *kwnames[] = {
21158 (char *) "win", NULL
21159 };
21160
21161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21163 if (SWIG_arg_fail(1)) SWIG_fail;
21164 {
21165 PyThreadState* __tstate = wxPyBeginAllowThreads();
21166 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21167
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 {
21172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21173 }
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj;
21182 char *kwnames[] = {
21183 NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 wxUpdateUIEvent::ResetUpdateTime();
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 Py_INCREF(Py_None); resultobj = Py_None;
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj;
21203 wxUpdateUIMode arg1 ;
21204 PyObject * obj0 = 0 ;
21205 char *kwnames[] = {
21206 (char *) "mode", NULL
21207 };
21208
21209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21210 {
21211 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21212 if (SWIG_arg_fail(1)) SWIG_fail;
21213 }
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 Py_INCREF(Py_None); resultobj = Py_None;
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj;
21230 wxUpdateUIMode result;
21231 char *kwnames[] = {
21232 NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21236 {
21237 PyThreadState* __tstate = wxPyBeginAllowThreads();
21238 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21239
21240 wxPyEndAllowThreads(__tstate);
21241 if (PyErr_Occurred()) SWIG_fail;
21242 }
21243 resultobj = SWIG_From_int((result));
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21251 PyObject *obj;
21252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21253 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21254 Py_INCREF(obj);
21255 return Py_BuildValue((char *)"");
21256 }
21257 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21258 PyObject *resultobj;
21259 wxSysColourChangedEvent *result;
21260 char *kwnames[] = {
21261 NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21280 PyObject *obj;
21281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21282 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21283 Py_INCREF(obj);
21284 return Py_BuildValue((char *)"");
21285 }
21286 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 int arg1 = (int) 0 ;
21289 wxWindow *arg2 = (wxWindow *) NULL ;
21290 wxMouseCaptureChangedEvent *result;
21291 PyObject * obj0 = 0 ;
21292 PyObject * obj1 = 0 ;
21293 char *kwnames[] = {
21294 (char *) "winid",(char *) "gainedCapture", NULL
21295 };
21296
21297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21298 if (obj0) {
21299 {
21300 arg1 = (int)(SWIG_As_int(obj0));
21301 if (SWIG_arg_fail(1)) SWIG_fail;
21302 }
21303 }
21304 if (obj1) {
21305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21306 if (SWIG_arg_fail(2)) SWIG_fail;
21307 }
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21311
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj;
21324 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21325 wxWindow *result;
21326 PyObject * obj0 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 {
21335 PyThreadState* __tstate = wxPyBeginAllowThreads();
21336 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 {
21342 resultobj = wxPyMake_wxObject(result, 0);
21343 }
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21351 PyObject *obj;
21352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21353 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21354 Py_INCREF(obj);
21355 return Py_BuildValue((char *)"");
21356 }
21357 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 wxDisplayChangedEvent *result;
21360 char *kwnames[] = {
21361 NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21380 PyObject *obj;
21381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21382 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21383 Py_INCREF(obj);
21384 return Py_BuildValue((char *)"");
21385 }
21386 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21387 PyObject *resultobj;
21388 int arg1 = (int) 0 ;
21389 wxPaletteChangedEvent *result;
21390 PyObject * obj0 = 0 ;
21391 char *kwnames[] = {
21392 (char *) "id", NULL
21393 };
21394
21395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21396 if (obj0) {
21397 {
21398 arg1 = (int)(SWIG_As_int(obj0));
21399 if (SWIG_arg_fail(1)) SWIG_fail;
21400 }
21401 }
21402 {
21403 PyThreadState* __tstate = wxPyBeginAllowThreads();
21404 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21405
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21417 PyObject *resultobj;
21418 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21419 wxWindow *arg2 = (wxWindow *) 0 ;
21420 PyObject * obj0 = 0 ;
21421 PyObject * obj1 = 0 ;
21422 char *kwnames[] = {
21423 (char *) "self",(char *) "win", NULL
21424 };
21425
21426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21430 if (SWIG_arg_fail(2)) SWIG_fail;
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 (arg1)->SetChangedWindow(arg2);
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 Py_INCREF(Py_None); resultobj = Py_None;
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21446 PyObject *resultobj;
21447 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21448 wxWindow *result;
21449 PyObject * obj0 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 {
21458 PyThreadState* __tstate = wxPyBeginAllowThreads();
21459 result = (wxWindow *)(arg1)->GetChangedWindow();
21460
21461 wxPyEndAllowThreads(__tstate);
21462 if (PyErr_Occurred()) SWIG_fail;
21463 }
21464 {
21465 resultobj = wxPyMake_wxObject(result, 0);
21466 }
21467 return resultobj;
21468 fail:
21469 return NULL;
21470 }
21471
21472
21473 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21474 PyObject *obj;
21475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21476 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21477 Py_INCREF(obj);
21478 return Py_BuildValue((char *)"");
21479 }
21480 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21481 PyObject *resultobj;
21482 int arg1 = (int) 0 ;
21483 wxQueryNewPaletteEvent *result;
21484 PyObject * obj0 = 0 ;
21485 char *kwnames[] = {
21486 (char *) "winid", NULL
21487 };
21488
21489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21490 if (obj0) {
21491 {
21492 arg1 = (int)(SWIG_As_int(obj0));
21493 if (SWIG_arg_fail(1)) SWIG_fail;
21494 }
21495 }
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21513 bool arg2 ;
21514 PyObject * obj0 = 0 ;
21515 PyObject * obj1 = 0 ;
21516 char *kwnames[] = {
21517 (char *) "self",(char *) "realized", NULL
21518 };
21519
21520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21522 if (SWIG_arg_fail(1)) SWIG_fail;
21523 {
21524 arg2 = (bool)(SWIG_As_bool(obj1));
21525 if (SWIG_arg_fail(2)) SWIG_fail;
21526 }
21527 {
21528 PyThreadState* __tstate = wxPyBeginAllowThreads();
21529 (arg1)->SetPaletteRealized(arg2);
21530
21531 wxPyEndAllowThreads(__tstate);
21532 if (PyErr_Occurred()) SWIG_fail;
21533 }
21534 Py_INCREF(Py_None); resultobj = Py_None;
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21542 PyObject *resultobj;
21543 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21544 bool result;
21545 PyObject * obj0 = 0 ;
21546 char *kwnames[] = {
21547 (char *) "self", NULL
21548 };
21549
21550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21552 if (SWIG_arg_fail(1)) SWIG_fail;
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21556
21557 wxPyEndAllowThreads(__tstate);
21558 if (PyErr_Occurred()) SWIG_fail;
21559 }
21560 {
21561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21562 }
21563 return resultobj;
21564 fail:
21565 return NULL;
21566 }
21567
21568
21569 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21570 PyObject *obj;
21571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21572 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21573 Py_INCREF(obj);
21574 return Py_BuildValue((char *)"");
21575 }
21576 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj;
21578 wxNavigationKeyEvent *result;
21579 char *kwnames[] = {
21580 NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21584 {
21585 PyThreadState* __tstate = wxPyBeginAllowThreads();
21586 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21587
21588 wxPyEndAllowThreads(__tstate);
21589 if (PyErr_Occurred()) SWIG_fail;
21590 }
21591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21599 PyObject *resultobj;
21600 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21601 bool result;
21602 PyObject * obj0 = 0 ;
21603 char *kwnames[] = {
21604 (char *) "self", NULL
21605 };
21606
21607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21609 if (SWIG_arg_fail(1)) SWIG_fail;
21610 {
21611 PyThreadState* __tstate = wxPyBeginAllowThreads();
21612 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21613
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 {
21618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21619 }
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21627 PyObject *resultobj;
21628 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21629 bool arg2 ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 char *kwnames[] = {
21633 (char *) "self",(char *) "forward", NULL
21634 };
21635
21636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21638 if (SWIG_arg_fail(1)) SWIG_fail;
21639 {
21640 arg2 = (bool)(SWIG_As_bool(obj1));
21641 if (SWIG_arg_fail(2)) SWIG_fail;
21642 }
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 (arg1)->SetDirection(arg2);
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 Py_INCREF(Py_None); resultobj = Py_None;
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21660 bool result;
21661 PyObject * obj0 = 0 ;
21662 char *kwnames[] = {
21663 (char *) "self", NULL
21664 };
21665
21666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21668 if (SWIG_arg_fail(1)) SWIG_fail;
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 {
21677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21678 }
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21686 PyObject *resultobj;
21687 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21688 bool arg2 ;
21689 PyObject * obj0 = 0 ;
21690 PyObject * obj1 = 0 ;
21691 char *kwnames[] = {
21692 (char *) "self",(char *) "ischange", NULL
21693 };
21694
21695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21697 if (SWIG_arg_fail(1)) SWIG_fail;
21698 {
21699 arg2 = (bool)(SWIG_As_bool(obj1));
21700 if (SWIG_arg_fail(2)) SWIG_fail;
21701 }
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 (arg1)->SetWindowChange(arg2);
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 Py_INCREF(Py_None); resultobj = Py_None;
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21719 bool result;
21720 PyObject * obj0 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21747 bool arg2 ;
21748 PyObject * obj0 = 0 ;
21749 PyObject * obj1 = 0 ;
21750 char *kwnames[] = {
21751 (char *) "self",(char *) "bIs", NULL
21752 };
21753
21754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21756 if (SWIG_arg_fail(1)) SWIG_fail;
21757 {
21758 arg2 = (bool)(SWIG_As_bool(obj1));
21759 if (SWIG_arg_fail(2)) SWIG_fail;
21760 }
21761 {
21762 PyThreadState* __tstate = wxPyBeginAllowThreads();
21763 (arg1)->SetFromTab(arg2);
21764
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 Py_INCREF(Py_None); resultobj = Py_None;
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj;
21777 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21778 long arg2 ;
21779 PyObject * obj0 = 0 ;
21780 PyObject * obj1 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self",(char *) "flags", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 {
21789 arg2 = (long)(SWIG_As_long(obj1));
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 }
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 (arg1)->SetFlags(arg2);
21795
21796 wxPyEndAllowThreads(__tstate);
21797 if (PyErr_Occurred()) SWIG_fail;
21798 }
21799 Py_INCREF(Py_None); resultobj = Py_None;
21800 return resultobj;
21801 fail:
21802 return NULL;
21803 }
21804
21805
21806 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21807 PyObject *resultobj;
21808 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21809 wxWindow *result;
21810 PyObject * obj0 = 0 ;
21811 char *kwnames[] = {
21812 (char *) "self", NULL
21813 };
21814
21815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(1)) SWIG_fail;
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 {
21826 resultobj = wxPyMake_wxObject(result, 0);
21827 }
21828 return resultobj;
21829 fail:
21830 return NULL;
21831 }
21832
21833
21834 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21835 PyObject *resultobj;
21836 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21837 wxWindow *arg2 = (wxWindow *) 0 ;
21838 PyObject * obj0 = 0 ;
21839 PyObject * obj1 = 0 ;
21840 char *kwnames[] = {
21841 (char *) "self",(char *) "win", NULL
21842 };
21843
21844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21846 if (SWIG_arg_fail(1)) SWIG_fail;
21847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(2)) SWIG_fail;
21849 {
21850 PyThreadState* __tstate = wxPyBeginAllowThreads();
21851 (arg1)->SetCurrentFocus(arg2);
21852
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 Py_INCREF(Py_None); resultobj = Py_None;
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21864 PyObject *obj;
21865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21866 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21867 Py_INCREF(obj);
21868 return Py_BuildValue((char *)"");
21869 }
21870 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21871 PyObject *resultobj;
21872 wxWindow *arg1 = (wxWindow *) NULL ;
21873 wxWindowCreateEvent *result;
21874 PyObject * obj0 = 0 ;
21875 char *kwnames[] = {
21876 (char *) "win", NULL
21877 };
21878
21879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21880 if (obj0) {
21881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21882 if (SWIG_arg_fail(1)) SWIG_fail;
21883 }
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21887
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21899 PyObject *resultobj;
21900 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21901 wxWindow *result;
21902 PyObject * obj0 = 0 ;
21903 char *kwnames[] = {
21904 (char *) "self", NULL
21905 };
21906
21907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21909 if (SWIG_arg_fail(1)) SWIG_fail;
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21913
21914 wxPyEndAllowThreads(__tstate);
21915 if (PyErr_Occurred()) SWIG_fail;
21916 }
21917 {
21918 resultobj = wxPyMake_wxObject(result, 0);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21927 PyObject *obj;
21928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21929 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21930 Py_INCREF(obj);
21931 return Py_BuildValue((char *)"");
21932 }
21933 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj;
21935 wxWindow *arg1 = (wxWindow *) NULL ;
21936 wxWindowDestroyEvent *result;
21937 PyObject * obj0 = 0 ;
21938 char *kwnames[] = {
21939 (char *) "win", NULL
21940 };
21941
21942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21943 if (obj0) {
21944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21945 if (SWIG_arg_fail(1)) SWIG_fail;
21946 }
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21950
21951 wxPyEndAllowThreads(__tstate);
21952 if (PyErr_Occurred()) SWIG_fail;
21953 }
21954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj;
21963 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21964 wxWindow *result;
21965 PyObject * obj0 = 0 ;
21966 char *kwnames[] = {
21967 (char *) "self", NULL
21968 };
21969
21970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21972 if (SWIG_arg_fail(1)) SWIG_fail;
21973 {
21974 PyThreadState* __tstate = wxPyBeginAllowThreads();
21975 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21976
21977 wxPyEndAllowThreads(__tstate);
21978 if (PyErr_Occurred()) SWIG_fail;
21979 }
21980 {
21981 resultobj = wxPyMake_wxObject(result, 0);
21982 }
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21990 PyObject *obj;
21991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21992 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21993 Py_INCREF(obj);
21994 return Py_BuildValue((char *)"");
21995 }
21996 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21997 PyObject *resultobj;
21998 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21999 int arg2 = (int) 0 ;
22000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22002 wxContextMenuEvent *result;
22003 wxPoint temp3 ;
22004 PyObject * obj0 = 0 ;
22005 PyObject * obj1 = 0 ;
22006 PyObject * obj2 = 0 ;
22007 char *kwnames[] = {
22008 (char *) "type",(char *) "winid",(char *) "pt", NULL
22009 };
22010
22011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22012 if (obj0) {
22013 {
22014 arg1 = (wxEventType)(SWIG_As_int(obj0));
22015 if (SWIG_arg_fail(1)) SWIG_fail;
22016 }
22017 }
22018 if (obj1) {
22019 {
22020 arg2 = (int)(SWIG_As_int(obj1));
22021 if (SWIG_arg_fail(2)) SWIG_fail;
22022 }
22023 }
22024 if (obj2) {
22025 {
22026 arg3 = &temp3;
22027 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22028 }
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj;
22046 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22047 wxPoint *result;
22048 PyObject * obj0 = 0 ;
22049 char *kwnames[] = {
22050 (char *) "self", NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22055 if (SWIG_arg_fail(1)) SWIG_fail;
22056 {
22057 PyThreadState* __tstate = wxPyBeginAllowThreads();
22058 {
22059 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22060 result = (wxPoint *) &_result_ref;
22061 }
22062
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22074 PyObject *resultobj;
22075 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22076 wxPoint *arg2 = 0 ;
22077 wxPoint temp2 ;
22078 PyObject * obj0 = 0 ;
22079 PyObject * obj1 = 0 ;
22080 char *kwnames[] = {
22081 (char *) "self",(char *) "pos", NULL
22082 };
22083
22084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22086 if (SWIG_arg_fail(1)) SWIG_fail;
22087 {
22088 arg2 = &temp2;
22089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 (arg1)->SetPosition((wxPoint const &)*arg2);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 Py_INCREF(Py_None); resultobj = Py_None;
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22106 PyObject *obj;
22107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22108 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22109 Py_INCREF(obj);
22110 return Py_BuildValue((char *)"");
22111 }
22112 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj;
22114 wxIdleEvent *result;
22115 char *kwnames[] = {
22116 NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (wxIdleEvent *)new wxIdleEvent();
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22137 bool arg2 = (bool) true ;
22138 PyObject * obj0 = 0 ;
22139 PyObject * obj1 = 0 ;
22140 char *kwnames[] = {
22141 (char *) "self",(char *) "needMore", NULL
22142 };
22143
22144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(1)) SWIG_fail;
22147 if (obj1) {
22148 {
22149 arg2 = (bool)(SWIG_As_bool(obj1));
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 }
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 (arg1)->RequestMore(arg2);
22156
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 Py_INCREF(Py_None); resultobj = Py_None;
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj;
22169 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22170 bool result;
22171 PyObject * obj0 = 0 ;
22172 char *kwnames[] = {
22173 (char *) "self", NULL
22174 };
22175
22176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22178 if (SWIG_arg_fail(1)) SWIG_fail;
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22188 }
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 wxIdleMode arg1 ;
22198 PyObject * obj0 = 0 ;
22199 char *kwnames[] = {
22200 (char *) "mode", NULL
22201 };
22202
22203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22204 {
22205 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22206 if (SWIG_arg_fail(1)) SWIG_fail;
22207 }
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 wxIdleEvent::SetMode((wxIdleMode )arg1);
22211
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 Py_INCREF(Py_None); resultobj = Py_None;
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj;
22224 wxIdleMode result;
22225 char *kwnames[] = {
22226 NULL
22227 };
22228
22229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (wxIdleMode)wxIdleEvent::GetMode();
22233
22234 wxPyEndAllowThreads(__tstate);
22235 if (PyErr_Occurred()) SWIG_fail;
22236 }
22237 resultobj = SWIG_From_int((result));
22238 return resultobj;
22239 fail:
22240 return NULL;
22241 }
22242
22243
22244 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22245 PyObject *resultobj;
22246 wxWindow *arg1 = (wxWindow *) 0 ;
22247 bool result;
22248 PyObject * obj0 = 0 ;
22249 char *kwnames[] = {
22250 (char *) "win", NULL
22251 };
22252
22253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22255 if (SWIG_arg_fail(1)) SWIG_fail;
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (bool)wxIdleEvent::CanSend(arg1);
22259
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 {
22264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22265 }
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22273 PyObject *obj;
22274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22275 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22276 Py_INCREF(obj);
22277 return Py_BuildValue((char *)"");
22278 }
22279 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 int arg1 = (int) 0 ;
22282 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22283 wxPyEvent *result;
22284 PyObject * obj0 = 0 ;
22285 PyObject * obj1 = 0 ;
22286 char *kwnames[] = {
22287 (char *) "winid",(char *) "eventType", NULL
22288 };
22289
22290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22291 if (obj0) {
22292 {
22293 arg1 = (int)(SWIG_As_int(obj0));
22294 if (SWIG_arg_fail(1)) SWIG_fail;
22295 }
22296 }
22297 if (obj1) {
22298 {
22299 arg2 = (wxEventType)(SWIG_As_int(obj1));
22300 if (SWIG_arg_fail(2)) SWIG_fail;
22301 }
22302 }
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22318 PyObject *resultobj;
22319 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22320 PyObject * obj0 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 delete arg1;
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 Py_INCREF(Py_None); resultobj = Py_None;
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22343 PyObject *resultobj;
22344 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22345 PyObject *arg2 = (PyObject *) 0 ;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 char *kwnames[] = {
22349 (char *) "self",(char *) "self", NULL
22350 };
22351
22352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(1)) SWIG_fail;
22355 arg2 = obj1;
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 (arg1)->SetSelf(arg2);
22359
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 Py_INCREF(Py_None); resultobj = Py_None;
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22371 PyObject *resultobj;
22372 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22373 PyObject *result;
22374 PyObject * obj0 = 0 ;
22375 char *kwnames[] = {
22376 (char *) "self", NULL
22377 };
22378
22379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(1)) SWIG_fail;
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = (PyObject *)(arg1)->GetSelf();
22385
22386 wxPyEndAllowThreads(__tstate);
22387 if (PyErr_Occurred()) SWIG_fail;
22388 }
22389 resultobj = result;
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22397 PyObject *obj;
22398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22399 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22400 Py_INCREF(obj);
22401 return Py_BuildValue((char *)"");
22402 }
22403 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj;
22405 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22406 int arg2 = (int) 0 ;
22407 wxPyCommandEvent *result;
22408 PyObject * obj0 = 0 ;
22409 PyObject * obj1 = 0 ;
22410 char *kwnames[] = {
22411 (char *) "eventType",(char *) "id", NULL
22412 };
22413
22414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22415 if (obj0) {
22416 {
22417 arg1 = (wxEventType)(SWIG_As_int(obj0));
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 }
22420 }
22421 if (obj1) {
22422 {
22423 arg2 = (int)(SWIG_As_int(obj1));
22424 if (SWIG_arg_fail(2)) SWIG_fail;
22425 }
22426 }
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22430
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22442 PyObject *resultobj;
22443 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22444 PyObject * obj0 = 0 ;
22445 char *kwnames[] = {
22446 (char *) "self", NULL
22447 };
22448
22449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22451 if (SWIG_arg_fail(1)) SWIG_fail;
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 delete arg1;
22455
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 Py_INCREF(Py_None); resultobj = Py_None;
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj;
22468 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22469 PyObject *arg2 = (PyObject *) 0 ;
22470 PyObject * obj0 = 0 ;
22471 PyObject * obj1 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self",(char *) "self", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 arg2 = obj1;
22480 {
22481 PyThreadState* __tstate = wxPyBeginAllowThreads();
22482 (arg1)->SetSelf(arg2);
22483
22484 wxPyEndAllowThreads(__tstate);
22485 if (PyErr_Occurred()) SWIG_fail;
22486 }
22487 Py_INCREF(Py_None); resultobj = Py_None;
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22495 PyObject *resultobj;
22496 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22497 PyObject *result;
22498 PyObject * obj0 = 0 ;
22499 char *kwnames[] = {
22500 (char *) "self", NULL
22501 };
22502
22503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
22504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22505 if (SWIG_arg_fail(1)) SWIG_fail;
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 result = (PyObject *)(arg1)->GetSelf();
22509
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 resultobj = result;
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22521 PyObject *obj;
22522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22523 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22524 Py_INCREF(obj);
22525 return Py_BuildValue((char *)"");
22526 }
22527 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22528 PyObject *resultobj;
22529 wxWindow *arg1 = (wxWindow *) 0 ;
22530 wxDateTime *arg2 = 0 ;
22531 wxEventType arg3 ;
22532 wxDateEvent *result;
22533 PyObject * obj0 = 0 ;
22534 PyObject * obj1 = 0 ;
22535 PyObject * obj2 = 0 ;
22536 char *kwnames[] = {
22537 (char *) "win",(char *) "dt",(char *) "type", NULL
22538 };
22539
22540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22542 if (SWIG_arg_fail(1)) SWIG_fail;
22543 {
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 if (arg2 == NULL) {
22547 SWIG_null_ref("wxDateTime");
22548 }
22549 if (SWIG_arg_fail(2)) SWIG_fail;
22550 }
22551 {
22552 arg3 = (wxEventType)(SWIG_As_int(obj2));
22553 if (SWIG_arg_fail(3)) SWIG_fail;
22554 }
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22558
22559 wxPyEndAllowThreads(__tstate);
22560 if (PyErr_Occurred()) SWIG_fail;
22561 }
22562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj;
22571 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22572 wxDateTime *result;
22573 PyObject * obj0 = 0 ;
22574 char *kwnames[] = {
22575 (char *) "self", NULL
22576 };
22577
22578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22580 if (SWIG_arg_fail(1)) SWIG_fail;
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 {
22584 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22585 result = (wxDateTime *) &_result_ref;
22586 }
22587
22588 wxPyEndAllowThreads(__tstate);
22589 if (PyErr_Occurred()) SWIG_fail;
22590 }
22591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22599 PyObject *resultobj;
22600 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22601 wxDateTime *arg2 = 0 ;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604 char *kwnames[] = {
22605 (char *) "self",(char *) "date", NULL
22606 };
22607
22608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22610 if (SWIG_arg_fail(1)) SWIG_fail;
22611 {
22612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22613 if (SWIG_arg_fail(2)) SWIG_fail;
22614 if (arg2 == NULL) {
22615 SWIG_null_ref("wxDateTime");
22616 }
22617 if (SWIG_arg_fail(2)) SWIG_fail;
22618 }
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 (arg1)->SetDate((wxDateTime const &)*arg2);
22622
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 Py_INCREF(Py_None); resultobj = Py_None;
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22634 PyObject *obj;
22635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22636 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22637 Py_INCREF(obj);
22638 return Py_BuildValue((char *)"");
22639 }
22640 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22641 PyObject *resultobj;
22642 wxPyApp *result;
22643 char *kwnames[] = {
22644 NULL
22645 };
22646
22647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 result = (wxPyApp *)new_wxPyApp();
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj;
22664 wxPyApp *arg1 = (wxPyApp *) 0 ;
22665 PyObject * obj0 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 delete arg1;
22676
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 Py_INCREF(Py_None); resultobj = Py_None;
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj;
22689 wxPyApp *arg1 = (wxPyApp *) 0 ;
22690 PyObject *arg2 = (PyObject *) 0 ;
22691 PyObject *arg3 = (PyObject *) 0 ;
22692 bool arg4 ;
22693 PyObject * obj0 = 0 ;
22694 PyObject * obj1 = 0 ;
22695 PyObject * obj2 = 0 ;
22696 PyObject * obj3 = 0 ;
22697 char *kwnames[] = {
22698 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22699 };
22700
22701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22703 if (SWIG_arg_fail(1)) SWIG_fail;
22704 arg2 = obj1;
22705 arg3 = obj2;
22706 {
22707 arg4 = (bool)(SWIG_As_bool(obj3));
22708 if (SWIG_arg_fail(4)) SWIG_fail;
22709 }
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22713
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 Py_INCREF(Py_None); resultobj = Py_None;
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22725 PyObject *resultobj;
22726 wxPyApp *arg1 = (wxPyApp *) 0 ;
22727 wxString result;
22728 PyObject * obj0 = 0 ;
22729 char *kwnames[] = {
22730 (char *) "self", NULL
22731 };
22732
22733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(1)) SWIG_fail;
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = ((wxPyApp const *)arg1)->GetAppName();
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 #if wxUSE_UNICODE
22745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22746 #else
22747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22748 #endif
22749 }
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22757 PyObject *resultobj;
22758 wxPyApp *arg1 = (wxPyApp *) 0 ;
22759 wxString *arg2 = 0 ;
22760 bool temp2 = false ;
22761 PyObject * obj0 = 0 ;
22762 PyObject * obj1 = 0 ;
22763 char *kwnames[] = {
22764 (char *) "self",(char *) "name", NULL
22765 };
22766
22767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22769 if (SWIG_arg_fail(1)) SWIG_fail;
22770 {
22771 arg2 = wxString_in_helper(obj1);
22772 if (arg2 == NULL) SWIG_fail;
22773 temp2 = true;
22774 }
22775 {
22776 PyThreadState* __tstate = wxPyBeginAllowThreads();
22777 (arg1)->SetAppName((wxString const &)*arg2);
22778
22779 wxPyEndAllowThreads(__tstate);
22780 if (PyErr_Occurred()) SWIG_fail;
22781 }
22782 Py_INCREF(Py_None); resultobj = Py_None;
22783 {
22784 if (temp2)
22785 delete arg2;
22786 }
22787 return resultobj;
22788 fail:
22789 {
22790 if (temp2)
22791 delete arg2;
22792 }
22793 return NULL;
22794 }
22795
22796
22797 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj;
22799 wxPyApp *arg1 = (wxPyApp *) 0 ;
22800 wxString result;
22801 PyObject * obj0 = 0 ;
22802 char *kwnames[] = {
22803 (char *) "self", NULL
22804 };
22805
22806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(1)) SWIG_fail;
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 result = ((wxPyApp const *)arg1)->GetClassName();
22812
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 #if wxUSE_UNICODE
22818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22819 #else
22820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22821 #endif
22822 }
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj;
22831 wxPyApp *arg1 = (wxPyApp *) 0 ;
22832 wxString *arg2 = 0 ;
22833 bool temp2 = false ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char *kwnames[] = {
22837 (char *) "self",(char *) "name", NULL
22838 };
22839
22840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22842 if (SWIG_arg_fail(1)) SWIG_fail;
22843 {
22844 arg2 = wxString_in_helper(obj1);
22845 if (arg2 == NULL) SWIG_fail;
22846 temp2 = true;
22847 }
22848 {
22849 PyThreadState* __tstate = wxPyBeginAllowThreads();
22850 (arg1)->SetClassName((wxString const &)*arg2);
22851
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 Py_INCREF(Py_None); resultobj = Py_None;
22856 {
22857 if (temp2)
22858 delete arg2;
22859 }
22860 return resultobj;
22861 fail:
22862 {
22863 if (temp2)
22864 delete arg2;
22865 }
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 wxPyApp *arg1 = (wxPyApp *) 0 ;
22873 wxString *result;
22874 PyObject * obj0 = 0 ;
22875 char *kwnames[] = {
22876 (char *) "self", NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22881 if (SWIG_arg_fail(1)) SWIG_fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 {
22885 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22886 result = (wxString *) &_result_ref;
22887 }
22888
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 {
22893 #if wxUSE_UNICODE
22894 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22895 #else
22896 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22897 #endif
22898 }
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22906 PyObject *resultobj;
22907 wxPyApp *arg1 = (wxPyApp *) 0 ;
22908 wxString *arg2 = 0 ;
22909 bool temp2 = false ;
22910 PyObject * obj0 = 0 ;
22911 PyObject * obj1 = 0 ;
22912 char *kwnames[] = {
22913 (char *) "self",(char *) "name", NULL
22914 };
22915
22916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22918 if (SWIG_arg_fail(1)) SWIG_fail;
22919 {
22920 arg2 = wxString_in_helper(obj1);
22921 if (arg2 == NULL) SWIG_fail;
22922 temp2 = true;
22923 }
22924 {
22925 PyThreadState* __tstate = wxPyBeginAllowThreads();
22926 (arg1)->SetVendorName((wxString const &)*arg2);
22927
22928 wxPyEndAllowThreads(__tstate);
22929 if (PyErr_Occurred()) SWIG_fail;
22930 }
22931 Py_INCREF(Py_None); resultobj = Py_None;
22932 {
22933 if (temp2)
22934 delete arg2;
22935 }
22936 return resultobj;
22937 fail:
22938 {
22939 if (temp2)
22940 delete arg2;
22941 }
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj;
22948 wxPyApp *arg1 = (wxPyApp *) 0 ;
22949 wxAppTraits *result;
22950 PyObject * obj0 = 0 ;
22951 char *kwnames[] = {
22952 (char *) "self", NULL
22953 };
22954
22955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22957 if (SWIG_arg_fail(1)) SWIG_fail;
22958 {
22959 PyThreadState* __tstate = wxPyBeginAllowThreads();
22960 result = (wxAppTraits *)(arg1)->GetTraits();
22961
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22973 PyObject *resultobj;
22974 wxPyApp *arg1 = (wxPyApp *) 0 ;
22975 PyObject * obj0 = 0 ;
22976 char *kwnames[] = {
22977 (char *) "self", NULL
22978 };
22979
22980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22982 if (SWIG_arg_fail(1)) SWIG_fail;
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 (arg1)->ProcessPendingEvents();
22986
22987 wxPyEndAllowThreads(__tstate);
22988 if (PyErr_Occurred()) SWIG_fail;
22989 }
22990 Py_INCREF(Py_None); resultobj = Py_None;
22991 return resultobj;
22992 fail:
22993 return NULL;
22994 }
22995
22996
22997 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj;
22999 wxPyApp *arg1 = (wxPyApp *) 0 ;
23000 bool arg2 = (bool) false ;
23001 bool result;
23002 PyObject * obj0 = 0 ;
23003 PyObject * obj1 = 0 ;
23004 char *kwnames[] = {
23005 (char *) "self",(char *) "onlyIfNeeded", NULL
23006 };
23007
23008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23010 if (SWIG_arg_fail(1)) SWIG_fail;
23011 if (obj1) {
23012 {
23013 arg2 = (bool)(SWIG_As_bool(obj1));
23014 if (SWIG_arg_fail(2)) SWIG_fail;
23015 }
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (bool)(arg1)->Yield(arg2);
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 {
23025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23026 }
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj;
23035 wxPyApp *arg1 = (wxPyApp *) 0 ;
23036 PyObject * obj0 = 0 ;
23037 char *kwnames[] = {
23038 (char *) "self", NULL
23039 };
23040
23041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23043 if (SWIG_arg_fail(1)) SWIG_fail;
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 (arg1)->WakeUpIdle();
23047
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 Py_INCREF(Py_None); resultobj = Py_None;
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 bool result;
23061 char *kwnames[] = {
23062 NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)wxPyApp::IsMainLoopRunning();
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 {
23074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj;
23084 wxPyApp *arg1 = (wxPyApp *) 0 ;
23085 int result;
23086 PyObject * obj0 = 0 ;
23087 char *kwnames[] = {
23088 (char *) "self", NULL
23089 };
23090
23091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23093 if (SWIG_arg_fail(1)) SWIG_fail;
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (int)(arg1)->MainLoop();
23097
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 {
23102 resultobj = SWIG_From_int((int)(result));
23103 }
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23111 PyObject *resultobj;
23112 wxPyApp *arg1 = (wxPyApp *) 0 ;
23113 PyObject * obj0 = 0 ;
23114 char *kwnames[] = {
23115 (char *) "self", NULL
23116 };
23117
23118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23120 if (SWIG_arg_fail(1)) SWIG_fail;
23121 {
23122 PyThreadState* __tstate = wxPyBeginAllowThreads();
23123 (arg1)->Exit();
23124
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 Py_INCREF(Py_None); resultobj = Py_None;
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj;
23137 wxPyApp *arg1 = (wxPyApp *) 0 ;
23138 PyObject * obj0 = 0 ;
23139 char *kwnames[] = {
23140 (char *) "self", NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(1)) SWIG_fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 (arg1)->ExitMainLoop();
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 Py_INCREF(Py_None); resultobj = Py_None;
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 wxPyApp *arg1 = (wxPyApp *) 0 ;
23163 bool result;
23164 PyObject * obj0 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "self", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)(arg1)->Pending();
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 wxPyApp *arg1 = (wxPyApp *) 0 ;
23191 bool result;
23192 PyObject * obj0 = 0 ;
23193 char *kwnames[] = {
23194 (char *) "self", NULL
23195 };
23196
23197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23199 if (SWIG_arg_fail(1)) SWIG_fail;
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (bool)(arg1)->Dispatch();
23203
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 wxPyApp *arg1 = (wxPyApp *) 0 ;
23219 bool result;
23220 PyObject * obj0 = 0 ;
23221 char *kwnames[] = {
23222 (char *) "self", NULL
23223 };
23224
23225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23227 if (SWIG_arg_fail(1)) SWIG_fail;
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = (bool)(arg1)->ProcessIdle();
23231
23232 wxPyEndAllowThreads(__tstate);
23233 if (PyErr_Occurred()) SWIG_fail;
23234 }
23235 {
23236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23237 }
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23245 PyObject *resultobj;
23246 wxPyApp *arg1 = (wxPyApp *) 0 ;
23247 wxWindow *arg2 = (wxWindow *) 0 ;
23248 wxIdleEvent *arg3 = 0 ;
23249 bool result;
23250 PyObject * obj0 = 0 ;
23251 PyObject * obj1 = 0 ;
23252 PyObject * obj2 = 0 ;
23253 char *kwnames[] = {
23254 (char *) "self",(char *) "win",(char *) "event", NULL
23255 };
23256
23257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23259 if (SWIG_arg_fail(1)) SWIG_fail;
23260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23261 if (SWIG_arg_fail(2)) SWIG_fail;
23262 {
23263 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(3)) SWIG_fail;
23265 if (arg3 == NULL) {
23266 SWIG_null_ref("wxIdleEvent");
23267 }
23268 if (SWIG_arg_fail(3)) SWIG_fail;
23269 }
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23273
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 {
23278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 wxPyApp *arg1 = (wxPyApp *) 0 ;
23289 bool result;
23290 PyObject * obj0 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 result = (bool)((wxPyApp const *)arg1)->IsActive();
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 wxPyApp *arg1 = (wxPyApp *) 0 ;
23317 wxWindow *arg2 = (wxWindow *) 0 ;
23318 PyObject * obj0 = 0 ;
23319 PyObject * obj1 = 0 ;
23320 char *kwnames[] = {
23321 (char *) "self",(char *) "win", NULL
23322 };
23323
23324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23326 if (SWIG_arg_fail(1)) SWIG_fail;
23327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(2)) SWIG_fail;
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 (arg1)->SetTopWindow(arg2);
23332
23333 wxPyEndAllowThreads(__tstate);
23334 if (PyErr_Occurred()) SWIG_fail;
23335 }
23336 Py_INCREF(Py_None); resultobj = Py_None;
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj;
23345 wxPyApp *arg1 = (wxPyApp *) 0 ;
23346 wxWindow *result;
23347 PyObject * obj0 = 0 ;
23348 char *kwnames[] = {
23349 (char *) "self", NULL
23350 };
23351
23352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23354 if (SWIG_arg_fail(1)) SWIG_fail;
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 {
23363 resultobj = wxPyMake_wxObject(result, 0);
23364 }
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxPyApp *arg1 = (wxPyApp *) 0 ;
23374 bool arg2 ;
23375 PyObject * obj0 = 0 ;
23376 PyObject * obj1 = 0 ;
23377 char *kwnames[] = {
23378 (char *) "self",(char *) "flag", NULL
23379 };
23380
23381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23383 if (SWIG_arg_fail(1)) SWIG_fail;
23384 {
23385 arg2 = (bool)(SWIG_As_bool(obj1));
23386 if (SWIG_arg_fail(2)) SWIG_fail;
23387 }
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 (arg1)->SetExitOnFrameDelete(arg2);
23391
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 Py_INCREF(Py_None); resultobj = Py_None;
23396 return resultobj;
23397 fail:
23398 return NULL;
23399 }
23400
23401
23402 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj;
23404 wxPyApp *arg1 = (wxPyApp *) 0 ;
23405 bool result;
23406 PyObject * obj0 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(1)) SWIG_fail;
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23423 }
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj;
23432 wxPyApp *arg1 = (wxPyApp *) 0 ;
23433 bool arg2 ;
23434 PyObject * obj0 = 0 ;
23435 PyObject * obj1 = 0 ;
23436 char *kwnames[] = {
23437 (char *) "self",(char *) "flag", NULL
23438 };
23439
23440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23442 if (SWIG_arg_fail(1)) SWIG_fail;
23443 {
23444 arg2 = (bool)(SWIG_As_bool(obj1));
23445 if (SWIG_arg_fail(2)) SWIG_fail;
23446 }
23447 {
23448 PyThreadState* __tstate = wxPyBeginAllowThreads();
23449 (arg1)->SetUseBestVisual(arg2);
23450
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 Py_INCREF(Py_None); resultobj = Py_None;
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj;
23463 wxPyApp *arg1 = (wxPyApp *) 0 ;
23464 bool result;
23465 PyObject * obj0 = 0 ;
23466 char *kwnames[] = {
23467 (char *) "self", NULL
23468 };
23469
23470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23472 if (SWIG_arg_fail(1)) SWIG_fail;
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23476
23477 wxPyEndAllowThreads(__tstate);
23478 if (PyErr_Occurred()) SWIG_fail;
23479 }
23480 {
23481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23482 }
23483 return resultobj;
23484 fail:
23485 return NULL;
23486 }
23487
23488
23489 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23490 PyObject *resultobj;
23491 wxPyApp *arg1 = (wxPyApp *) 0 ;
23492 int arg2 ;
23493 PyObject * obj0 = 0 ;
23494 PyObject * obj1 = 0 ;
23495 char *kwnames[] = {
23496 (char *) "self",(char *) "mode", NULL
23497 };
23498
23499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23501 if (SWIG_arg_fail(1)) SWIG_fail;
23502 {
23503 arg2 = (int)(SWIG_As_int(obj1));
23504 if (SWIG_arg_fail(2)) SWIG_fail;
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 (arg1)->SetPrintMode(arg2);
23509
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 Py_INCREF(Py_None); resultobj = Py_None;
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 wxPyApp *arg1 = (wxPyApp *) 0 ;
23523 int result;
23524 PyObject * obj0 = 0 ;
23525 char *kwnames[] = {
23526 (char *) "self", NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23531 if (SWIG_arg_fail(1)) SWIG_fail;
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23535
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 {
23540 resultobj = SWIG_From_int((int)(result));
23541 }
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 wxPyApp *arg1 = (wxPyApp *) 0 ;
23551 int arg2 ;
23552 PyObject * obj0 = 0 ;
23553 PyObject * obj1 = 0 ;
23554 char *kwnames[] = {
23555 (char *) "self",(char *) "mode", NULL
23556 };
23557
23558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23560 if (SWIG_arg_fail(1)) SWIG_fail;
23561 {
23562 arg2 = (int)(SWIG_As_int(obj1));
23563 if (SWIG_arg_fail(2)) SWIG_fail;
23564 }
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 (arg1)->SetAssertMode(arg2);
23568
23569 wxPyEndAllowThreads(__tstate);
23570 if (PyErr_Occurred()) SWIG_fail;
23571 }
23572 Py_INCREF(Py_None); resultobj = Py_None;
23573 return resultobj;
23574 fail:
23575 return NULL;
23576 }
23577
23578
23579 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23580 PyObject *resultobj;
23581 wxPyApp *arg1 = (wxPyApp *) 0 ;
23582 int result;
23583 PyObject * obj0 = 0 ;
23584 char *kwnames[] = {
23585 (char *) "self", NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23590 if (SWIG_arg_fail(1)) SWIG_fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (int)(arg1)->GetAssertMode();
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_int((int)(result));
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 bool result;
23610 char *kwnames[] = {
23611 NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj;
23633 long result;
23634 char *kwnames[] = {
23635 NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = (long)wxPyApp::GetMacAboutMenuItemId();
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 resultobj = SWIG_From_long((long)(result));
23648 }
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj;
23657 long result;
23658 char *kwnames[] = {
23659 NULL
23660 };
23661
23662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23666
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 {
23671 resultobj = SWIG_From_long((long)(result));
23672 }
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23680 PyObject *resultobj;
23681 long result;
23682 char *kwnames[] = {
23683 NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = (long)wxPyApp::GetMacExitMenuItemId();
23690
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 resultobj = SWIG_From_long((long)(result));
23696 }
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23704 PyObject *resultobj;
23705 wxString result;
23706 char *kwnames[] = {
23707 NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = wxPyApp::GetMacHelpMenuTitleName();
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 {
23719 #if wxUSE_UNICODE
23720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23721 #else
23722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23723 #endif
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 bool arg1 ;
23734 PyObject * obj0 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "val", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23740 {
23741 arg1 = (bool)(SWIG_As_bool(obj0));
23742 if (SWIG_arg_fail(1)) SWIG_fail;
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23747
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 Py_INCREF(Py_None); resultobj = Py_None;
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj;
23760 long arg1 ;
23761 PyObject * obj0 = 0 ;
23762 char *kwnames[] = {
23763 (char *) "val", NULL
23764 };
23765
23766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23767 {
23768 arg1 = (long)(SWIG_As_long(obj0));
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 wxPyApp::SetMacAboutMenuItemId(arg1);
23774
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 Py_INCREF(Py_None); resultobj = Py_None;
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj;
23787 long arg1 ;
23788 PyObject * obj0 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "val", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23794 {
23795 arg1 = (long)(SWIG_As_long(obj0));
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 }
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 Py_INCREF(Py_None); resultobj = Py_None;
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23813 PyObject *resultobj;
23814 long arg1 ;
23815 PyObject * obj0 = 0 ;
23816 char *kwnames[] = {
23817 (char *) "val", NULL
23818 };
23819
23820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23821 {
23822 arg1 = (long)(SWIG_As_long(obj0));
23823 if (SWIG_arg_fail(1)) SWIG_fail;
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 wxPyApp::SetMacExitMenuItemId(arg1);
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 Py_INCREF(Py_None); resultobj = Py_None;
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxString *arg1 = 0 ;
23842 bool temp1 = false ;
23843 PyObject * obj0 = 0 ;
23844 char *kwnames[] = {
23845 (char *) "val", NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23849 {
23850 arg1 = wxString_in_helper(obj0);
23851 if (arg1 == NULL) SWIG_fail;
23852 temp1 = true;
23853 }
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23857
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 Py_INCREF(Py_None); resultobj = Py_None;
23862 {
23863 if (temp1)
23864 delete arg1;
23865 }
23866 return resultobj;
23867 fail:
23868 {
23869 if (temp1)
23870 delete arg1;
23871 }
23872 return NULL;
23873 }
23874
23875
23876 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj;
23878 wxPyApp *arg1 = (wxPyApp *) 0 ;
23879 PyObject * obj0 = 0 ;
23880 char *kwnames[] = {
23881 (char *) "self", NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23886 if (SWIG_arg_fail(1)) SWIG_fail;
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 (arg1)->_BootstrapApp();
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 Py_INCREF(Py_None); resultobj = Py_None;
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj;
23903 int result;
23904 char *kwnames[] = {
23905 NULL
23906 };
23907
23908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (int)PyApp_GetComCtl32Version();
23912
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 {
23917 resultobj = SWIG_From_int((int)(result));
23918 }
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23926 PyObject *obj;
23927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23928 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23929 Py_INCREF(obj);
23930 return Py_BuildValue((char *)"");
23931 }
23932 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj;
23934 char *kwnames[] = {
23935 NULL
23936 };
23937
23938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 wxExit();
23942
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 Py_INCREF(Py_None); resultobj = Py_None;
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj;
23955 bool result;
23956 char *kwnames[] = {
23957 NULL
23958 };
23959
23960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)wxYield();
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 bool result;
23980 char *kwnames[] = {
23981 NULL
23982 };
23983
23984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 result = (bool)wxYieldIfNeeded();
23988
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 {
23993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23994 }
23995 return resultobj;
23996 fail:
23997 return NULL;
23998 }
23999
24000
24001 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj;
24003 wxWindow *arg1 = (wxWindow *) NULL ;
24004 bool arg2 = (bool) false ;
24005 bool result;
24006 PyObject * obj0 = 0 ;
24007 PyObject * obj1 = 0 ;
24008 char *kwnames[] = {
24009 (char *) "win",(char *) "onlyIfNeeded", NULL
24010 };
24011
24012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24013 if (obj0) {
24014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24015 if (SWIG_arg_fail(1)) SWIG_fail;
24016 }
24017 if (obj1) {
24018 {
24019 arg2 = (bool)(SWIG_As_bool(obj1));
24020 if (SWIG_arg_fail(2)) SWIG_fail;
24021 }
24022 }
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (bool)wxSafeYield(arg1,arg2);
24026
24027 wxPyEndAllowThreads(__tstate);
24028 if (PyErr_Occurred()) SWIG_fail;
24029 }
24030 {
24031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24032 }
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24040 PyObject *resultobj;
24041 char *kwnames[] = {
24042 NULL
24043 };
24044
24045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 wxWakeUpIdle();
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 Py_INCREF(Py_None); resultobj = Py_None;
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24063 wxEvent *arg2 = 0 ;
24064 PyObject * obj0 = 0 ;
24065 PyObject * obj1 = 0 ;
24066 char *kwnames[] = {
24067 (char *) "dest",(char *) "event", NULL
24068 };
24069
24070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24072 if (SWIG_arg_fail(1)) SWIG_fail;
24073 {
24074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24075 if (SWIG_arg_fail(2)) SWIG_fail;
24076 if (arg2 == NULL) {
24077 SWIG_null_ref("wxEvent");
24078 }
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 }
24081 {
24082 PyThreadState* __tstate = wxPyBeginAllowThreads();
24083 wxPostEvent(arg1,*arg2);
24084
24085 wxPyEndAllowThreads(__tstate);
24086 if (PyErr_Occurred()) SWIG_fail;
24087 }
24088 Py_INCREF(Py_None); resultobj = Py_None;
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 char *kwnames[] = {
24098 NULL
24099 };
24100
24101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 wxApp_CleanUp();
24105
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 Py_INCREF(Py_None); resultobj = Py_None;
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxPyApp *result;
24119 char *kwnames[] = {
24120 NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (wxPyApp *)wxPyGetApp();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 {
24132 resultobj = wxPyMake_wxObject(result, 0);
24133 }
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 char *arg1 = (char *) 0 ;
24143 PyObject * obj0 = 0 ;
24144 char *kwnames[] = {
24145 (char *) "encoding", NULL
24146 };
24147
24148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24149 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24150 SWIG_arg_fail(1);SWIG_fail;
24151 }
24152 {
24153 PyThreadState* __tstate = wxPyBeginAllowThreads();
24154 wxSetDefaultPyEncoding((char const *)arg1);
24155
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 Py_INCREF(Py_None); resultobj = Py_None;
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 char *result;
24169 char *kwnames[] = {
24170 NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 result = (char *)wxGetDefaultPyEncoding();
24177
24178 wxPyEndAllowThreads(__tstate);
24179 if (PyErr_Occurred()) SWIG_fail;
24180 }
24181 resultobj = SWIG_FromCharPtr(result);
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24189 PyObject *resultobj;
24190 wxEventLoop *result;
24191 char *kwnames[] = {
24192 NULL
24193 };
24194
24195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24196 {
24197 PyThreadState* __tstate = wxPyBeginAllowThreads();
24198 result = (wxEventLoop *)new wxEventLoop();
24199
24200 wxPyEndAllowThreads(__tstate);
24201 if (PyErr_Occurred()) SWIG_fail;
24202 }
24203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24211 PyObject *resultobj;
24212 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24213 PyObject * obj0 = 0 ;
24214 char *kwnames[] = {
24215 (char *) "self", NULL
24216 };
24217
24218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24220 if (SWIG_arg_fail(1)) SWIG_fail;
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 delete arg1;
24224
24225 wxPyEndAllowThreads(__tstate);
24226 if (PyErr_Occurred()) SWIG_fail;
24227 }
24228 Py_INCREF(Py_None); resultobj = Py_None;
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24236 PyObject *resultobj;
24237 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24238 int result;
24239 PyObject * obj0 = 0 ;
24240 char *kwnames[] = {
24241 (char *) "self", NULL
24242 };
24243
24244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24246 if (SWIG_arg_fail(1)) SWIG_fail;
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 result = (int)(arg1)->Run();
24250
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 {
24255 resultobj = SWIG_From_int((int)(result));
24256 }
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24264 PyObject *resultobj;
24265 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24266 int arg2 = (int) 0 ;
24267 PyObject * obj0 = 0 ;
24268 PyObject * obj1 = 0 ;
24269 char *kwnames[] = {
24270 (char *) "self",(char *) "rc", NULL
24271 };
24272
24273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24275 if (SWIG_arg_fail(1)) SWIG_fail;
24276 if (obj1) {
24277 {
24278 arg2 = (int)(SWIG_As_int(obj1));
24279 if (SWIG_arg_fail(2)) SWIG_fail;
24280 }
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 (arg1)->Exit(arg2);
24285
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 Py_INCREF(Py_None); resultobj = Py_None;
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24299 bool result;
24300 PyObject * obj0 = 0 ;
24301 char *kwnames[] = {
24302 (char *) "self", NULL
24303 };
24304
24305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (bool)((wxEventLoop const *)arg1)->Pending();
24311
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24325 PyObject *resultobj;
24326 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24327 bool result;
24328 PyObject * obj0 = 0 ;
24329 char *kwnames[] = {
24330 (char *) "self", NULL
24331 };
24332
24333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(1)) SWIG_fail;
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (bool)(arg1)->Dispatch();
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 {
24344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24345 }
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24355 bool result;
24356 PyObject * obj0 = 0 ;
24357 char *kwnames[] = {
24358 (char *) "self", NULL
24359 };
24360
24361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24363 if (SWIG_arg_fail(1)) SWIG_fail;
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24367
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 {
24372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24373 }
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj;
24382 wxEventLoop *result;
24383 char *kwnames[] = {
24384 NULL
24385 };
24386
24387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = (wxEventLoop *)wxEventLoop::GetActive();
24391
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "loop", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 wxEventLoop::SetActive(arg1);
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 Py_INCREF(Py_None); resultobj = Py_None;
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24428 PyObject *obj;
24429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24430 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24431 Py_INCREF(obj);
24432 return Py_BuildValue((char *)"");
24433 }
24434 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj;
24436 int arg1 = (int) 0 ;
24437 int arg2 = (int) 0 ;
24438 int arg3 = (int) 0 ;
24439 wxAcceleratorEntry *result;
24440 PyObject * obj0 = 0 ;
24441 PyObject * obj1 = 0 ;
24442 PyObject * obj2 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24448 if (obj0) {
24449 {
24450 arg1 = (int)(SWIG_As_int(obj0));
24451 if (SWIG_arg_fail(1)) SWIG_fail;
24452 }
24453 }
24454 if (obj1) {
24455 {
24456 arg2 = (int)(SWIG_As_int(obj1));
24457 if (SWIG_arg_fail(2)) SWIG_fail;
24458 }
24459 }
24460 if (obj2) {
24461 {
24462 arg3 = (int)(SWIG_As_int(obj2));
24463 if (SWIG_arg_fail(3)) SWIG_fail;
24464 }
24465 }
24466 {
24467 PyThreadState* __tstate = wxPyBeginAllowThreads();
24468 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24469
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj;
24482 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 delete arg1;
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 Py_INCREF(Py_None); resultobj = Py_None;
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj;
24507 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24508 int arg2 ;
24509 int arg3 ;
24510 int arg4 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 PyObject * obj2 = 0 ;
24514 PyObject * obj3 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24521 if (SWIG_arg_fail(1)) SWIG_fail;
24522 {
24523 arg2 = (int)(SWIG_As_int(obj1));
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 }
24526 {
24527 arg3 = (int)(SWIG_As_int(obj2));
24528 if (SWIG_arg_fail(3)) SWIG_fail;
24529 }
24530 {
24531 arg4 = (int)(SWIG_As_int(obj3));
24532 if (SWIG_arg_fail(4)) SWIG_fail;
24533 }
24534 {
24535 PyThreadState* __tstate = wxPyBeginAllowThreads();
24536 (arg1)->Set(arg2,arg3,arg4);
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_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24551 int result;
24552 PyObject * obj0 = 0 ;
24553 char *kwnames[] = {
24554 (char *) "self", NULL
24555 };
24556
24557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24559 if (SWIG_arg_fail(1)) SWIG_fail;
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (int)(arg1)->GetFlags();
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 resultobj = SWIG_From_int((int)(result));
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24579 int result;
24580 PyObject * obj0 = 0 ;
24581 char *kwnames[] = {
24582 (char *) "self", NULL
24583 };
24584
24585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 {
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 result = (int)(arg1)->GetKeyCode();
24591
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 {
24596 resultobj = SWIG_From_int((int)(result));
24597 }
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24605 PyObject *resultobj;
24606 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24607 int result;
24608 PyObject * obj0 = 0 ;
24609 char *kwnames[] = {
24610 (char *) "self", NULL
24611 };
24612
24613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24615 if (SWIG_arg_fail(1)) SWIG_fail;
24616 {
24617 PyThreadState* __tstate = wxPyBeginAllowThreads();
24618 result = (int)(arg1)->GetCommand();
24619
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 {
24624 resultobj = SWIG_From_int((int)(result));
24625 }
24626 return resultobj;
24627 fail:
24628 return NULL;
24629 }
24630
24631
24632 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24633 PyObject *obj;
24634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24635 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24636 Py_INCREF(obj);
24637 return Py_BuildValue((char *)"");
24638 }
24639 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 int arg1 ;
24642 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24643 wxAcceleratorTable *result;
24644 PyObject * obj0 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "n", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24650 {
24651 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24652 if (arg2) arg1 = PyList_Size(obj0);
24653 else arg1 = 0;
24654 }
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24658
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24663 {
24664 delete [] arg2;
24665 }
24666 return resultobj;
24667 fail:
24668 {
24669 delete [] arg2;
24670 }
24671 return NULL;
24672 }
24673
24674
24675 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj;
24677 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24678 PyObject * obj0 = 0 ;
24679 char *kwnames[] = {
24680 (char *) "self", NULL
24681 };
24682
24683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24685 if (SWIG_arg_fail(1)) SWIG_fail;
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 delete arg1;
24689
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 Py_INCREF(Py_None); resultobj = Py_None;
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj;
24702 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24703 bool result;
24704 PyObject * obj0 = 0 ;
24705 char *kwnames[] = {
24706 (char *) "self", NULL
24707 };
24708
24709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24711 if (SWIG_arg_fail(1)) SWIG_fail;
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24715
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 {
24720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24721 }
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24729 PyObject *obj;
24730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24731 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24732 Py_INCREF(obj);
24733 return Py_BuildValue((char *)"");
24734 }
24735 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24736 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24737 return 1;
24738 }
24739
24740
24741 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24742 PyObject *pyobj;
24743
24744 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24745 return pyobj;
24746 }
24747
24748
24749 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24750 PyObject *resultobj;
24751 wxString *arg1 = 0 ;
24752 wxAcceleratorEntry *result;
24753 bool temp1 = false ;
24754 PyObject * obj0 = 0 ;
24755 char *kwnames[] = {
24756 (char *) "label", NULL
24757 };
24758
24759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24760 {
24761 arg1 = wxString_in_helper(obj0);
24762 if (arg1 == NULL) SWIG_fail;
24763 temp1 = true;
24764 }
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24768
24769 wxPyEndAllowThreads(__tstate);
24770 if (PyErr_Occurred()) SWIG_fail;
24771 }
24772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24773 {
24774 if (temp1)
24775 delete arg1;
24776 }
24777 return resultobj;
24778 fail:
24779 {
24780 if (temp1)
24781 delete arg1;
24782 }
24783 return NULL;
24784 }
24785
24786
24787 static int _wrap_PanelNameStr_set(PyObject *) {
24788 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24789 return 1;
24790 }
24791
24792
24793 static PyObject *_wrap_PanelNameStr_get(void) {
24794 PyObject *pyobj;
24795
24796 {
24797 #if wxUSE_UNICODE
24798 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24799 #else
24800 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24801 #endif
24802 }
24803 return pyobj;
24804 }
24805
24806
24807 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj;
24809 wxVisualAttributes *result;
24810 char *kwnames[] = {
24811 NULL
24812 };
24813
24814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (wxVisualAttributes *)new_wxVisualAttributes();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj;
24831 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24832 PyObject * obj0 = 0 ;
24833 char *kwnames[] = {
24834 (char *) "self", NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(1)) SWIG_fail;
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 delete_wxVisualAttributes(arg1);
24843
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 Py_INCREF(Py_None); resultobj = Py_None;
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj;
24856 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24857 wxFont *arg2 = (wxFont *) 0 ;
24858 PyObject * obj0 = 0 ;
24859 PyObject * obj1 = 0 ;
24860 char *kwnames[] = {
24861 (char *) "self",(char *) "font", NULL
24862 };
24863
24864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24866 if (SWIG_arg_fail(1)) SWIG_fail;
24867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24868 if (SWIG_arg_fail(2)) SWIG_fail;
24869 if (arg1) (arg1)->font = *arg2;
24870
24871 Py_INCREF(Py_None); resultobj = Py_None;
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj;
24880 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24881 wxFont *result;
24882 PyObject * obj0 = 0 ;
24883 char *kwnames[] = {
24884 (char *) "self", NULL
24885 };
24886
24887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24889 if (SWIG_arg_fail(1)) SWIG_fail;
24890 result = (wxFont *)& ((arg1)->font);
24891
24892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24893 return resultobj;
24894 fail:
24895 return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24900 PyObject *resultobj;
24901 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24902 wxColour *arg2 = (wxColour *) 0 ;
24903 PyObject * obj0 = 0 ;
24904 PyObject * obj1 = 0 ;
24905 char *kwnames[] = {
24906 (char *) "self",(char *) "colFg", NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(1)) SWIG_fail;
24912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(2)) SWIG_fail;
24914 if (arg1) (arg1)->colFg = *arg2;
24915
24916 Py_INCREF(Py_None); resultobj = Py_None;
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj;
24925 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24926 wxColour *result;
24927 PyObject * obj0 = 0 ;
24928 char *kwnames[] = {
24929 (char *) "self", NULL
24930 };
24931
24932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(1)) SWIG_fail;
24935 result = (wxColour *)& ((arg1)->colFg);
24936
24937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24947 wxColour *arg2 = (wxColour *) 0 ;
24948 PyObject * obj0 = 0 ;
24949 PyObject * obj1 = 0 ;
24950 char *kwnames[] = {
24951 (char *) "self",(char *) "colBg", NULL
24952 };
24953
24954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24956 if (SWIG_arg_fail(1)) SWIG_fail;
24957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24958 if (SWIG_arg_fail(2)) SWIG_fail;
24959 if (arg1) (arg1)->colBg = *arg2;
24960
24961 Py_INCREF(Py_None); resultobj = Py_None;
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj;
24970 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24971 wxColour *result;
24972 PyObject * obj0 = 0 ;
24973 char *kwnames[] = {
24974 (char *) "self", NULL
24975 };
24976
24977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24979 if (SWIG_arg_fail(1)) SWIG_fail;
24980 result = (wxColour *)& ((arg1)->colBg);
24981
24982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24990 PyObject *obj;
24991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24992 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24993 Py_INCREF(obj);
24994 return Py_BuildValue((char *)"");
24995 }
24996 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj;
24998 wxWindow *arg1 = (wxWindow *) 0 ;
24999 int arg2 = (int) (int)-1 ;
25000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25002 wxSize const &arg4_defvalue = wxDefaultSize ;
25003 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25004 long arg5 = (long) 0 ;
25005 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25006 wxString *arg6 = (wxString *) &arg6_defvalue ;
25007 wxWindow *result;
25008 wxPoint temp3 ;
25009 wxSize temp4 ;
25010 bool temp6 = false ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 PyObject * obj2 = 0 ;
25014 PyObject * obj3 = 0 ;
25015 PyObject * obj4 = 0 ;
25016 PyObject * obj5 = 0 ;
25017 char *kwnames[] = {
25018 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25019 };
25020
25021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25023 if (SWIG_arg_fail(1)) SWIG_fail;
25024 if (obj1) {
25025 {
25026 arg2 = (int const)(SWIG_As_int(obj1));
25027 if (SWIG_arg_fail(2)) SWIG_fail;
25028 }
25029 }
25030 if (obj2) {
25031 {
25032 arg3 = &temp3;
25033 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25034 }
25035 }
25036 if (obj3) {
25037 {
25038 arg4 = &temp4;
25039 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25040 }
25041 }
25042 if (obj4) {
25043 {
25044 arg5 = (long)(SWIG_As_long(obj4));
25045 if (SWIG_arg_fail(5)) SWIG_fail;
25046 }
25047 }
25048 if (obj5) {
25049 {
25050 arg6 = wxString_in_helper(obj5);
25051 if (arg6 == NULL) SWIG_fail;
25052 temp6 = true;
25053 }
25054 }
25055 {
25056 if (!wxPyCheckForApp()) SWIG_fail;
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25059
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25064 {
25065 if (temp6)
25066 delete arg6;
25067 }
25068 return resultobj;
25069 fail:
25070 {
25071 if (temp6)
25072 delete arg6;
25073 }
25074 return NULL;
25075 }
25076
25077
25078 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj;
25080 wxWindow *result;
25081 char *kwnames[] = {
25082 NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25086 {
25087 if (!wxPyCheckForApp()) SWIG_fail;
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (wxWindow *)new wxWindow();
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25102 PyObject *resultobj;
25103 wxWindow *arg1 = (wxWindow *) 0 ;
25104 wxWindow *arg2 = (wxWindow *) 0 ;
25105 int arg3 = (int) (int)-1 ;
25106 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25107 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25108 wxSize const &arg5_defvalue = wxDefaultSize ;
25109 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25110 long arg6 = (long) 0 ;
25111 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25112 wxString *arg7 = (wxString *) &arg7_defvalue ;
25113 bool result;
25114 wxPoint temp4 ;
25115 wxSize temp5 ;
25116 bool temp7 = false ;
25117 PyObject * obj0 = 0 ;
25118 PyObject * obj1 = 0 ;
25119 PyObject * obj2 = 0 ;
25120 PyObject * obj3 = 0 ;
25121 PyObject * obj4 = 0 ;
25122 PyObject * obj5 = 0 ;
25123 PyObject * obj6 = 0 ;
25124 char *kwnames[] = {
25125 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25126 };
25127
25128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25130 if (SWIG_arg_fail(1)) SWIG_fail;
25131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25132 if (SWIG_arg_fail(2)) SWIG_fail;
25133 if (obj2) {
25134 {
25135 arg3 = (int const)(SWIG_As_int(obj2));
25136 if (SWIG_arg_fail(3)) SWIG_fail;
25137 }
25138 }
25139 if (obj3) {
25140 {
25141 arg4 = &temp4;
25142 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25143 }
25144 }
25145 if (obj4) {
25146 {
25147 arg5 = &temp5;
25148 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25149 }
25150 }
25151 if (obj5) {
25152 {
25153 arg6 = (long)(SWIG_As_long(obj5));
25154 if (SWIG_arg_fail(6)) SWIG_fail;
25155 }
25156 }
25157 if (obj6) {
25158 {
25159 arg7 = wxString_in_helper(obj6);
25160 if (arg7 == NULL) SWIG_fail;
25161 temp7 = true;
25162 }
25163 }
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25173 }
25174 {
25175 if (temp7)
25176 delete arg7;
25177 }
25178 return resultobj;
25179 fail:
25180 {
25181 if (temp7)
25182 delete arg7;
25183 }
25184 return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj;
25190 wxWindow *arg1 = (wxWindow *) 0 ;
25191 bool arg2 = (bool) false ;
25192 bool result;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 char *kwnames[] = {
25196 (char *) "self",(char *) "force", NULL
25197 };
25198
25199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 if (obj1) {
25203 {
25204 arg2 = (bool)(SWIG_As_bool(obj1));
25205 if (SWIG_arg_fail(2)) SWIG_fail;
25206 }
25207 }
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (bool)(arg1)->Close(arg2);
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 wxWindow *arg1 = (wxWindow *) 0 ;
25227 bool result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "self", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25235 if (SWIG_arg_fail(1)) SWIG_fail;
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 result = (bool)(arg1)->Destroy();
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 {
25244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25245 }
25246 return resultobj;
25247 fail:
25248 return NULL;
25249 }
25250
25251
25252 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj;
25254 wxWindow *arg1 = (wxWindow *) 0 ;
25255 bool result;
25256 PyObject * obj0 = 0 ;
25257 char *kwnames[] = {
25258 (char *) "self", NULL
25259 };
25260
25261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25263 if (SWIG_arg_fail(1)) SWIG_fail;
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (bool)(arg1)->DestroyChildren();
25267
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 {
25272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25273 }
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 bool result;
25284 PyObject * obj0 = 0 ;
25285 char *kwnames[] = {
25286 (char *) "self", NULL
25287 };
25288
25289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25291 if (SWIG_arg_fail(1)) SWIG_fail;
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25295
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 {
25300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25301 }
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25309 PyObject *resultobj;
25310 wxWindow *arg1 = (wxWindow *) 0 ;
25311 wxString *arg2 = 0 ;
25312 bool temp2 = false ;
25313 PyObject * obj0 = 0 ;
25314 PyObject * obj1 = 0 ;
25315 char *kwnames[] = {
25316 (char *) "self",(char *) "title", NULL
25317 };
25318
25319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25321 if (SWIG_arg_fail(1)) SWIG_fail;
25322 {
25323 arg2 = wxString_in_helper(obj1);
25324 if (arg2 == NULL) SWIG_fail;
25325 temp2 = true;
25326 }
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 (arg1)->SetTitle((wxString const &)*arg2);
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 Py_INCREF(Py_None); resultobj = Py_None;
25335 {
25336 if (temp2)
25337 delete arg2;
25338 }
25339 return resultobj;
25340 fail:
25341 {
25342 if (temp2)
25343 delete arg2;
25344 }
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxWindow *arg1 = (wxWindow *) 0 ;
25352 wxString result;
25353 PyObject * obj0 = 0 ;
25354 char *kwnames[] = {
25355 (char *) "self", NULL
25356 };
25357
25358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25360 if (SWIG_arg_fail(1)) SWIG_fail;
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = ((wxWindow const *)arg1)->GetTitle();
25364
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 {
25369 #if wxUSE_UNICODE
25370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25371 #else
25372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25373 #endif
25374 }
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 wxString *arg2 = 0 ;
25385 bool temp2 = false ;
25386 PyObject * obj0 = 0 ;
25387 PyObject * obj1 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "self",(char *) "label", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 {
25396 arg2 = wxString_in_helper(obj1);
25397 if (arg2 == NULL) SWIG_fail;
25398 temp2 = true;
25399 }
25400 {
25401 PyThreadState* __tstate = wxPyBeginAllowThreads();
25402 (arg1)->SetLabel((wxString const &)*arg2);
25403
25404 wxPyEndAllowThreads(__tstate);
25405 if (PyErr_Occurred()) SWIG_fail;
25406 }
25407 Py_INCREF(Py_None); resultobj = Py_None;
25408 {
25409 if (temp2)
25410 delete arg2;
25411 }
25412 return resultobj;
25413 fail:
25414 {
25415 if (temp2)
25416 delete arg2;
25417 }
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 wxWindow *arg1 = (wxWindow *) 0 ;
25425 wxString result;
25426 PyObject * obj0 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "self", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 result = ((wxWindow const *)arg1)->GetLabel();
25437
25438 wxPyEndAllowThreads(__tstate);
25439 if (PyErr_Occurred()) SWIG_fail;
25440 }
25441 {
25442 #if wxUSE_UNICODE
25443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25444 #else
25445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25446 #endif
25447 }
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj;
25456 wxWindow *arg1 = (wxWindow *) 0 ;
25457 wxString *arg2 = 0 ;
25458 bool temp2 = false ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 char *kwnames[] = {
25462 (char *) "self",(char *) "name", NULL
25463 };
25464
25465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25467 if (SWIG_arg_fail(1)) SWIG_fail;
25468 {
25469 arg2 = wxString_in_helper(obj1);
25470 if (arg2 == NULL) SWIG_fail;
25471 temp2 = true;
25472 }
25473 {
25474 PyThreadState* __tstate = wxPyBeginAllowThreads();
25475 (arg1)->SetName((wxString const &)*arg2);
25476
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 Py_INCREF(Py_None); resultobj = Py_None;
25481 {
25482 if (temp2)
25483 delete arg2;
25484 }
25485 return resultobj;
25486 fail:
25487 {
25488 if (temp2)
25489 delete arg2;
25490 }
25491 return NULL;
25492 }
25493
25494
25495 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj;
25497 wxWindow *arg1 = (wxWindow *) 0 ;
25498 wxString result;
25499 PyObject * obj0 = 0 ;
25500 char *kwnames[] = {
25501 (char *) "self", NULL
25502 };
25503
25504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25506 if (SWIG_arg_fail(1)) SWIG_fail;
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = ((wxWindow const *)arg1)->GetName();
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 {
25515 #if wxUSE_UNICODE
25516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25517 #else
25518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25519 #endif
25520 }
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj;
25529 wxWindow *arg1 = (wxWindow *) 0 ;
25530 wxWindowVariant arg2 ;
25531 PyObject * obj0 = 0 ;
25532 PyObject * obj1 = 0 ;
25533 char *kwnames[] = {
25534 (char *) "self",(char *) "variant", NULL
25535 };
25536
25537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25539 if (SWIG_arg_fail(1)) SWIG_fail;
25540 {
25541 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25542 if (SWIG_arg_fail(2)) SWIG_fail;
25543 }
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25547
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 Py_INCREF(Py_None); resultobj = Py_None;
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj;
25560 wxWindow *arg1 = (wxWindow *) 0 ;
25561 wxWindowVariant result;
25562 PyObject * obj0 = 0 ;
25563 char *kwnames[] = {
25564 (char *) "self", NULL
25565 };
25566
25567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25569 if (SWIG_arg_fail(1)) SWIG_fail;
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25573
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_From_int((result));
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25585 PyObject *resultobj;
25586 wxWindow *arg1 = (wxWindow *) 0 ;
25587 int arg2 ;
25588 PyObject * obj0 = 0 ;
25589 PyObject * obj1 = 0 ;
25590 char *kwnames[] = {
25591 (char *) "self",(char *) "winid", NULL
25592 };
25593
25594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25596 if (SWIG_arg_fail(1)) SWIG_fail;
25597 {
25598 arg2 = (int)(SWIG_As_int(obj1));
25599 if (SWIG_arg_fail(2)) SWIG_fail;
25600 }
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 (arg1)->SetId(arg2);
25604
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 Py_INCREF(Py_None); resultobj = Py_None;
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 wxWindow *arg1 = (wxWindow *) 0 ;
25618 int result;
25619 PyObject * obj0 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "self", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25626 if (SWIG_arg_fail(1)) SWIG_fail;
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (int)((wxWindow const *)arg1)->GetId();
25630
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = SWIG_From_int((int)(result));
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 int result;
25646 char *kwnames[] = {
25647 NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = (int)wxWindow::NewControlId();
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 {
25659 resultobj = SWIG_From_int((int)(result));
25660 }
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 int arg1 ;
25670 int result;
25671 PyObject * obj0 = 0 ;
25672 char *kwnames[] = {
25673 (char *) "winid", NULL
25674 };
25675
25676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25677 {
25678 arg1 = (int)(SWIG_As_int(obj0));
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 }
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (int)wxWindow::NextControlId(arg1);
25684
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 {
25689 resultobj = SWIG_From_int((int)(result));
25690 }
25691 return resultobj;
25692 fail:
25693 return NULL;
25694 }
25695
25696
25697 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj;
25699 int arg1 ;
25700 int result;
25701 PyObject * obj0 = 0 ;
25702 char *kwnames[] = {
25703 (char *) "winid", NULL
25704 };
25705
25706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25707 {
25708 arg1 = (int)(SWIG_As_int(obj0));
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 }
25711 {
25712 PyThreadState* __tstate = wxPyBeginAllowThreads();
25713 result = (int)wxWindow::PrevControlId(arg1);
25714
25715 wxPyEndAllowThreads(__tstate);
25716 if (PyErr_Occurred()) SWIG_fail;
25717 }
25718 {
25719 resultobj = SWIG_From_int((int)(result));
25720 }
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj;
25729 wxWindow *arg1 = (wxWindow *) 0 ;
25730 wxSize *arg2 = 0 ;
25731 wxSize temp2 ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char *kwnames[] = {
25735 (char *) "self",(char *) "size", NULL
25736 };
25737
25738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25740 if (SWIG_arg_fail(1)) SWIG_fail;
25741 {
25742 arg2 = &temp2;
25743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25744 }
25745 {
25746 PyThreadState* __tstate = wxPyBeginAllowThreads();
25747 (arg1)->SetSize((wxSize const &)*arg2);
25748
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 Py_INCREF(Py_None); resultobj = Py_None;
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25760 PyObject *resultobj;
25761 wxWindow *arg1 = (wxWindow *) 0 ;
25762 int arg2 ;
25763 int arg3 ;
25764 int arg4 ;
25765 int arg5 ;
25766 int arg6 = (int) wxSIZE_AUTO ;
25767 PyObject * obj0 = 0 ;
25768 PyObject * obj1 = 0 ;
25769 PyObject * obj2 = 0 ;
25770 PyObject * obj3 = 0 ;
25771 PyObject * obj4 = 0 ;
25772 PyObject * obj5 = 0 ;
25773 char *kwnames[] = {
25774 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25775 };
25776
25777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25779 if (SWIG_arg_fail(1)) SWIG_fail;
25780 {
25781 arg2 = (int)(SWIG_As_int(obj1));
25782 if (SWIG_arg_fail(2)) SWIG_fail;
25783 }
25784 {
25785 arg3 = (int)(SWIG_As_int(obj2));
25786 if (SWIG_arg_fail(3)) SWIG_fail;
25787 }
25788 {
25789 arg4 = (int)(SWIG_As_int(obj3));
25790 if (SWIG_arg_fail(4)) SWIG_fail;
25791 }
25792 {
25793 arg5 = (int)(SWIG_As_int(obj4));
25794 if (SWIG_arg_fail(5)) SWIG_fail;
25795 }
25796 if (obj5) {
25797 {
25798 arg6 = (int)(SWIG_As_int(obj5));
25799 if (SWIG_arg_fail(6)) SWIG_fail;
25800 }
25801 }
25802 {
25803 PyThreadState* __tstate = wxPyBeginAllowThreads();
25804 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25805
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 Py_INCREF(Py_None); resultobj = Py_None;
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxWindow *arg1 = (wxWindow *) 0 ;
25819 wxRect *arg2 = 0 ;
25820 int arg3 = (int) wxSIZE_AUTO ;
25821 wxRect temp2 ;
25822 PyObject * obj0 = 0 ;
25823 PyObject * obj1 = 0 ;
25824 PyObject * obj2 = 0 ;
25825 char *kwnames[] = {
25826 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25827 };
25828
25829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25831 if (SWIG_arg_fail(1)) SWIG_fail;
25832 {
25833 arg2 = &temp2;
25834 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25835 }
25836 if (obj2) {
25837 {
25838 arg3 = (int)(SWIG_As_int(obj2));
25839 if (SWIG_arg_fail(3)) SWIG_fail;
25840 }
25841 }
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25845
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 Py_INCREF(Py_None); resultobj = Py_None;
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxWindow *arg1 = (wxWindow *) 0 ;
25859 int arg2 ;
25860 int arg3 ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 PyObject * obj2 = 0 ;
25864 char *kwnames[] = {
25865 (char *) "self",(char *) "width",(char *) "height", NULL
25866 };
25867
25868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25870 if (SWIG_arg_fail(1)) SWIG_fail;
25871 {
25872 arg2 = (int)(SWIG_As_int(obj1));
25873 if (SWIG_arg_fail(2)) SWIG_fail;
25874 }
25875 {
25876 arg3 = (int)(SWIG_As_int(obj2));
25877 if (SWIG_arg_fail(3)) SWIG_fail;
25878 }
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 (arg1)->SetSize(arg2,arg3);
25882
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 Py_INCREF(Py_None); resultobj = Py_None;
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25894 PyObject *resultobj;
25895 wxWindow *arg1 = (wxWindow *) 0 ;
25896 wxPoint *arg2 = 0 ;
25897 int arg3 = (int) wxSIZE_USE_EXISTING ;
25898 wxPoint temp2 ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 PyObject * obj2 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "pt",(char *) "flags", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 arg2 = &temp2;
25911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25912 }
25913 if (obj2) {
25914 {
25915 arg3 = (int)(SWIG_As_int(obj2));
25916 if (SWIG_arg_fail(3)) SWIG_fail;
25917 }
25918 }
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 (arg1)->Move((wxPoint const &)*arg2,arg3);
25922
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 Py_INCREF(Py_None); resultobj = Py_None;
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25934 PyObject *resultobj;
25935 wxWindow *arg1 = (wxWindow *) 0 ;
25936 int arg2 ;
25937 int arg3 ;
25938 int arg4 = (int) wxSIZE_USE_EXISTING ;
25939 PyObject * obj0 = 0 ;
25940 PyObject * obj1 = 0 ;
25941 PyObject * obj2 = 0 ;
25942 PyObject * obj3 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25949 if (SWIG_arg_fail(1)) SWIG_fail;
25950 {
25951 arg2 = (int)(SWIG_As_int(obj1));
25952 if (SWIG_arg_fail(2)) SWIG_fail;
25953 }
25954 {
25955 arg3 = (int)(SWIG_As_int(obj2));
25956 if (SWIG_arg_fail(3)) SWIG_fail;
25957 }
25958 if (obj3) {
25959 {
25960 arg4 = (int)(SWIG_As_int(obj3));
25961 if (SWIG_arg_fail(4)) SWIG_fail;
25962 }
25963 }
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 (arg1)->Move(arg2,arg3,arg4);
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 Py_INCREF(Py_None); resultobj = Py_None;
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj;
25980 wxWindow *arg1 = (wxWindow *) 0 ;
25981 wxSize const &arg2_defvalue = wxDefaultSize ;
25982 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25983 wxSize temp2 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 char *kwnames[] = {
25987 (char *) "self",(char *) "size", NULL
25988 };
25989
25990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25992 if (SWIG_arg_fail(1)) SWIG_fail;
25993 if (obj1) {
25994 {
25995 arg2 = &temp2;
25996 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25997 }
25998 }
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26002
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 Py_INCREF(Py_None); resultobj = Py_None;
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj;
26015 wxWindow *arg1 = (wxWindow *) 0 ;
26016 PyObject * obj0 = 0 ;
26017 char *kwnames[] = {
26018 (char *) "self", NULL
26019 };
26020
26021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26023 if (SWIG_arg_fail(1)) SWIG_fail;
26024 {
26025 PyThreadState* __tstate = wxPyBeginAllowThreads();
26026 (arg1)->Raise();
26027
26028 wxPyEndAllowThreads(__tstate);
26029 if (PyErr_Occurred()) SWIG_fail;
26030 }
26031 Py_INCREF(Py_None); resultobj = Py_None;
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26039 PyObject *resultobj;
26040 wxWindow *arg1 = (wxWindow *) 0 ;
26041 PyObject * obj0 = 0 ;
26042 char *kwnames[] = {
26043 (char *) "self", NULL
26044 };
26045
26046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26048 if (SWIG_arg_fail(1)) SWIG_fail;
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->Lower();
26052
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 Py_INCREF(Py_None); resultobj = Py_None;
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj;
26065 wxWindow *arg1 = (wxWindow *) 0 ;
26066 wxSize *arg2 = 0 ;
26067 wxSize temp2 ;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 char *kwnames[] = {
26071 (char *) "self",(char *) "size", NULL
26072 };
26073
26074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26076 if (SWIG_arg_fail(1)) SWIG_fail;
26077 {
26078 arg2 = &temp2;
26079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26080 }
26081 {
26082 PyThreadState* __tstate = wxPyBeginAllowThreads();
26083 (arg1)->SetClientSize((wxSize const &)*arg2);
26084
26085 wxPyEndAllowThreads(__tstate);
26086 if (PyErr_Occurred()) SWIG_fail;
26087 }
26088 Py_INCREF(Py_None); resultobj = Py_None;
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj;
26097 wxWindow *arg1 = (wxWindow *) 0 ;
26098 int arg2 ;
26099 int arg3 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 PyObject * obj2 = 0 ;
26103 char *kwnames[] = {
26104 (char *) "self",(char *) "width",(char *) "height", NULL
26105 };
26106
26107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(1)) SWIG_fail;
26110 {
26111 arg2 = (int)(SWIG_As_int(obj1));
26112 if (SWIG_arg_fail(2)) SWIG_fail;
26113 }
26114 {
26115 arg3 = (int)(SWIG_As_int(obj2));
26116 if (SWIG_arg_fail(3)) SWIG_fail;
26117 }
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 (arg1)->SetClientSize(arg2,arg3);
26121
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 Py_INCREF(Py_None); resultobj = Py_None;
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj;
26134 wxWindow *arg1 = (wxWindow *) 0 ;
26135 wxRect *arg2 = 0 ;
26136 wxRect temp2 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char *kwnames[] = {
26140 (char *) "self",(char *) "rect", NULL
26141 };
26142
26143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26145 if (SWIG_arg_fail(1)) SWIG_fail;
26146 {
26147 arg2 = &temp2;
26148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26149 }
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 (arg1)->SetClientSize((wxRect const &)*arg2);
26153
26154 wxPyEndAllowThreads(__tstate);
26155 if (PyErr_Occurred()) SWIG_fail;
26156 }
26157 Py_INCREF(Py_None); resultobj = Py_None;
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj;
26166 wxWindow *arg1 = (wxWindow *) 0 ;
26167 wxPoint result;
26168 PyObject * obj0 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = (arg1)->GetPosition();
26179
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 {
26184 wxPoint * resultptr;
26185 resultptr = new wxPoint((wxPoint &)(result));
26186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26187 }
26188 return resultobj;
26189 fail:
26190 return NULL;
26191 }
26192
26193
26194 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26195 PyObject *resultobj;
26196 wxWindow *arg1 = (wxWindow *) 0 ;
26197 int *arg2 = (int *) 0 ;
26198 int *arg3 = (int *) 0 ;
26199 int temp2 ;
26200 int res2 = 0 ;
26201 int temp3 ;
26202 int res3 = 0 ;
26203 PyObject * obj0 = 0 ;
26204 char *kwnames[] = {
26205 (char *) "self", NULL
26206 };
26207
26208 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26209 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 (arg1)->GetPosition(arg2,arg3);
26216
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 Py_INCREF(Py_None); resultobj = Py_None;
26221 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26222 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26223 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26224 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj;
26233 wxWindow *arg1 = (wxWindow *) 0 ;
26234 wxSize result;
26235 PyObject * obj0 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = ((wxWindow const *)arg1)->GetSize();
26246
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 wxSize * resultptr;
26252 resultptr = new wxSize((wxSize &)(result));
26253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26254 }
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26262 PyObject *resultobj;
26263 wxWindow *arg1 = (wxWindow *) 0 ;
26264 int *arg2 = (int *) 0 ;
26265 int *arg3 = (int *) 0 ;
26266 int temp2 ;
26267 int res2 = 0 ;
26268 int temp3 ;
26269 int res3 = 0 ;
26270 PyObject * obj0 = 0 ;
26271 char *kwnames[] = {
26272 (char *) "self", NULL
26273 };
26274
26275 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26276 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26279 if (SWIG_arg_fail(1)) SWIG_fail;
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26283
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 Py_INCREF(Py_None); resultobj = Py_None;
26288 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26289 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26290 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26291 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26299 PyObject *resultobj;
26300 wxWindow *arg1 = (wxWindow *) 0 ;
26301 wxRect result;
26302 PyObject * obj0 = 0 ;
26303 char *kwnames[] = {
26304 (char *) "self", NULL
26305 };
26306
26307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26309 if (SWIG_arg_fail(1)) SWIG_fail;
26310 {
26311 PyThreadState* __tstate = wxPyBeginAllowThreads();
26312 result = ((wxWindow const *)arg1)->GetRect();
26313
26314 wxPyEndAllowThreads(__tstate);
26315 if (PyErr_Occurred()) SWIG_fail;
26316 }
26317 {
26318 wxRect * resultptr;
26319 resultptr = new wxRect((wxRect &)(result));
26320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26321 }
26322 return resultobj;
26323 fail:
26324 return NULL;
26325 }
26326
26327
26328 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26329 PyObject *resultobj;
26330 wxWindow *arg1 = (wxWindow *) 0 ;
26331 wxSize result;
26332 PyObject * obj0 = 0 ;
26333 char *kwnames[] = {
26334 (char *) "self", NULL
26335 };
26336
26337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26339 if (SWIG_arg_fail(1)) SWIG_fail;
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 result = ((wxWindow const *)arg1)->GetClientSize();
26343
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 {
26348 wxSize * resultptr;
26349 resultptr = new wxSize((wxSize &)(result));
26350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26351 }
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj;
26360 wxWindow *arg1 = (wxWindow *) 0 ;
26361 int *arg2 = (int *) 0 ;
26362 int *arg3 = (int *) 0 ;
26363 int temp2 ;
26364 int res2 = 0 ;
26365 int temp3 ;
26366 int res3 = 0 ;
26367 PyObject * obj0 = 0 ;
26368 char *kwnames[] = {
26369 (char *) "self", NULL
26370 };
26371
26372 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26373 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 Py_INCREF(Py_None); resultobj = Py_None;
26385 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26386 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26387 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26388 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj;
26397 wxWindow *arg1 = (wxWindow *) 0 ;
26398 wxPoint result;
26399 PyObject * obj0 = 0 ;
26400 char *kwnames[] = {
26401 (char *) "self", NULL
26402 };
26403
26404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(1)) SWIG_fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 {
26415 wxPoint * resultptr;
26416 resultptr = new wxPoint((wxPoint &)(result));
26417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxWindow *arg1 = (wxWindow *) 0 ;
26428 wxRect result;
26429 PyObject * obj0 = 0 ;
26430 char *kwnames[] = {
26431 (char *) "self", NULL
26432 };
26433
26434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26436 if (SWIG_arg_fail(1)) SWIG_fail;
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = ((wxWindow const *)arg1)->GetClientRect();
26440
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 {
26445 wxRect * resultptr;
26446 resultptr = new wxRect((wxRect &)(result));
26447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26448 }
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj;
26457 wxWindow *arg1 = (wxWindow *) 0 ;
26458 wxSize result;
26459 PyObject * obj0 = 0 ;
26460 char *kwnames[] = {
26461 (char *) "self", NULL
26462 };
26463
26464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26466 if (SWIG_arg_fail(1)) SWIG_fail;
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 result = ((wxWindow const *)arg1)->GetBestSize();
26470
26471 wxPyEndAllowThreads(__tstate);
26472 if (PyErr_Occurred()) SWIG_fail;
26473 }
26474 {
26475 wxSize * resultptr;
26476 resultptr = new wxSize((wxSize &)(result));
26477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26478 }
26479 return resultobj;
26480 fail:
26481 return NULL;
26482 }
26483
26484
26485 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26486 PyObject *resultobj;
26487 wxWindow *arg1 = (wxWindow *) 0 ;
26488 int *arg2 = (int *) 0 ;
26489 int *arg3 = (int *) 0 ;
26490 int temp2 ;
26491 int res2 = 0 ;
26492 int temp3 ;
26493 int res3 = 0 ;
26494 PyObject * obj0 = 0 ;
26495 char *kwnames[] = {
26496 (char *) "self", NULL
26497 };
26498
26499 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26500 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26503 if (SWIG_arg_fail(1)) SWIG_fail;
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26507
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 Py_INCREF(Py_None); resultobj = Py_None;
26512 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26513 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26514 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26515 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 wxWindow *arg1 = (wxWindow *) 0 ;
26525 PyObject * obj0 = 0 ;
26526 char *kwnames[] = {
26527 (char *) "self", NULL
26528 };
26529
26530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26532 if (SWIG_arg_fail(1)) SWIG_fail;
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 (arg1)->InvalidateBestSize();
26536
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 Py_INCREF(Py_None); resultobj = Py_None;
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj;
26549 wxWindow *arg1 = (wxWindow *) 0 ;
26550 wxSize *arg2 = 0 ;
26551 wxSize temp2 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char *kwnames[] = {
26555 (char *) "self",(char *) "size", NULL
26556 };
26557
26558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
26559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26560 if (SWIG_arg_fail(1)) SWIG_fail;
26561 {
26562 arg2 = &temp2;
26563 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26564 }
26565 {
26566 PyThreadState* __tstate = wxPyBeginAllowThreads();
26567 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
26568
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 Py_INCREF(Py_None); resultobj = Py_None;
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26580 PyObject *resultobj;
26581 wxWindow *arg1 = (wxWindow *) 0 ;
26582 wxSize result;
26583 PyObject * obj0 = 0 ;
26584 char *kwnames[] = {
26585 (char *) "self", NULL
26586 };
26587
26588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26590 if (SWIG_arg_fail(1)) SWIG_fail;
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26594
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 {
26599 wxSize * resultptr;
26600 resultptr = new wxSize((wxSize &)(result));
26601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26602 }
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj;
26611 wxWindow *arg1 = (wxWindow *) 0 ;
26612 wxSize result;
26613 PyObject * obj0 = 0 ;
26614 char *kwnames[] = {
26615 (char *) "self", NULL
26616 };
26617
26618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26620 if (SWIG_arg_fail(1)) SWIG_fail;
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26624
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 {
26629 wxSize * resultptr;
26630 resultptr = new wxSize((wxSize &)(result));
26631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26632 }
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj;
26641 wxWindow *arg1 = (wxWindow *) 0 ;
26642 int arg2 = (int) wxBOTH ;
26643 PyObject * obj0 = 0 ;
26644 PyObject * obj1 = 0 ;
26645 char *kwnames[] = {
26646 (char *) "self",(char *) "direction", NULL
26647 };
26648
26649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26651 if (SWIG_arg_fail(1)) SWIG_fail;
26652 if (obj1) {
26653 {
26654 arg2 = (int)(SWIG_As_int(obj1));
26655 if (SWIG_arg_fail(2)) SWIG_fail;
26656 }
26657 }
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->Center(arg2);
26661
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 Py_INCREF(Py_None); resultobj = Py_None;
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26673 PyObject *resultobj;
26674 wxWindow *arg1 = (wxWindow *) 0 ;
26675 int arg2 = (int) wxBOTH ;
26676 PyObject * obj0 = 0 ;
26677 PyObject * obj1 = 0 ;
26678 char *kwnames[] = {
26679 (char *) "self",(char *) "dir", NULL
26680 };
26681
26682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26684 if (SWIG_arg_fail(1)) SWIG_fail;
26685 if (obj1) {
26686 {
26687 arg2 = (int)(SWIG_As_int(obj1));
26688 if (SWIG_arg_fail(2)) SWIG_fail;
26689 }
26690 }
26691 {
26692 PyThreadState* __tstate = wxPyBeginAllowThreads();
26693 (arg1)->CenterOnScreen(arg2);
26694
26695 wxPyEndAllowThreads(__tstate);
26696 if (PyErr_Occurred()) SWIG_fail;
26697 }
26698 Py_INCREF(Py_None); resultobj = Py_None;
26699 return resultobj;
26700 fail:
26701 return NULL;
26702 }
26703
26704
26705 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26706 PyObject *resultobj;
26707 wxWindow *arg1 = (wxWindow *) 0 ;
26708 int arg2 = (int) wxBOTH ;
26709 PyObject * obj0 = 0 ;
26710 PyObject * obj1 = 0 ;
26711 char *kwnames[] = {
26712 (char *) "self",(char *) "dir", NULL
26713 };
26714
26715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26717 if (SWIG_arg_fail(1)) SWIG_fail;
26718 if (obj1) {
26719 {
26720 arg2 = (int)(SWIG_As_int(obj1));
26721 if (SWIG_arg_fail(2)) SWIG_fail;
26722 }
26723 }
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 (arg1)->CenterOnParent(arg2);
26727
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 Py_INCREF(Py_None); resultobj = Py_None;
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj;
26740 wxWindow *arg1 = (wxWindow *) 0 ;
26741 PyObject * obj0 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 (arg1)->Fit();
26752
26753 wxPyEndAllowThreads(__tstate);
26754 if (PyErr_Occurred()) SWIG_fail;
26755 }
26756 Py_INCREF(Py_None); resultobj = Py_None;
26757 return resultobj;
26758 fail:
26759 return NULL;
26760 }
26761
26762
26763 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26764 PyObject *resultobj;
26765 wxWindow *arg1 = (wxWindow *) 0 ;
26766 PyObject * obj0 = 0 ;
26767 char *kwnames[] = {
26768 (char *) "self", NULL
26769 };
26770
26771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26773 if (SWIG_arg_fail(1)) SWIG_fail;
26774 {
26775 PyThreadState* __tstate = wxPyBeginAllowThreads();
26776 (arg1)->FitInside();
26777
26778 wxPyEndAllowThreads(__tstate);
26779 if (PyErr_Occurred()) SWIG_fail;
26780 }
26781 Py_INCREF(Py_None); resultobj = Py_None;
26782 return resultobj;
26783 fail:
26784 return NULL;
26785 }
26786
26787
26788 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26789 PyObject *resultobj;
26790 wxWindow *arg1 = (wxWindow *) 0 ;
26791 int arg2 ;
26792 int arg3 ;
26793 int arg4 = (int) -1 ;
26794 int arg5 = (int) -1 ;
26795 int arg6 = (int) -1 ;
26796 int arg7 = (int) -1 ;
26797 PyObject * obj0 = 0 ;
26798 PyObject * obj1 = 0 ;
26799 PyObject * obj2 = 0 ;
26800 PyObject * obj3 = 0 ;
26801 PyObject * obj4 = 0 ;
26802 PyObject * obj5 = 0 ;
26803 PyObject * obj6 = 0 ;
26804 char *kwnames[] = {
26805 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26806 };
26807
26808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26810 if (SWIG_arg_fail(1)) SWIG_fail;
26811 {
26812 arg2 = (int)(SWIG_As_int(obj1));
26813 if (SWIG_arg_fail(2)) SWIG_fail;
26814 }
26815 {
26816 arg3 = (int)(SWIG_As_int(obj2));
26817 if (SWIG_arg_fail(3)) SWIG_fail;
26818 }
26819 if (obj3) {
26820 {
26821 arg4 = (int)(SWIG_As_int(obj3));
26822 if (SWIG_arg_fail(4)) SWIG_fail;
26823 }
26824 }
26825 if (obj4) {
26826 {
26827 arg5 = (int)(SWIG_As_int(obj4));
26828 if (SWIG_arg_fail(5)) SWIG_fail;
26829 }
26830 }
26831 if (obj5) {
26832 {
26833 arg6 = (int)(SWIG_As_int(obj5));
26834 if (SWIG_arg_fail(6)) SWIG_fail;
26835 }
26836 }
26837 if (obj6) {
26838 {
26839 arg7 = (int)(SWIG_As_int(obj6));
26840 if (SWIG_arg_fail(7)) SWIG_fail;
26841 }
26842 }
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26846
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 Py_INCREF(Py_None); resultobj = Py_None;
26851 return resultobj;
26852 fail:
26853 return NULL;
26854 }
26855
26856
26857 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26858 PyObject *resultobj;
26859 wxWindow *arg1 = (wxWindow *) 0 ;
26860 wxSize *arg2 = 0 ;
26861 wxSize const &arg3_defvalue = wxDefaultSize ;
26862 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26863 wxSize const &arg4_defvalue = wxDefaultSize ;
26864 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26865 wxSize temp2 ;
26866 wxSize temp3 ;
26867 wxSize temp4 ;
26868 PyObject * obj0 = 0 ;
26869 PyObject * obj1 = 0 ;
26870 PyObject * obj2 = 0 ;
26871 PyObject * obj3 = 0 ;
26872 char *kwnames[] = {
26873 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26874 };
26875
26876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26878 if (SWIG_arg_fail(1)) SWIG_fail;
26879 {
26880 arg2 = &temp2;
26881 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26882 }
26883 if (obj2) {
26884 {
26885 arg3 = &temp3;
26886 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26887 }
26888 }
26889 if (obj3) {
26890 {
26891 arg4 = &temp4;
26892 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26893 }
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26898
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 Py_INCREF(Py_None); resultobj = Py_None;
26903 return resultobj;
26904 fail:
26905 return NULL;
26906 }
26907
26908
26909 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26910 PyObject *resultobj;
26911 wxWindow *arg1 = (wxWindow *) 0 ;
26912 int arg2 ;
26913 int arg3 ;
26914 int arg4 = (int) -1 ;
26915 int arg5 = (int) -1 ;
26916 PyObject * obj0 = 0 ;
26917 PyObject * obj1 = 0 ;
26918 PyObject * obj2 = 0 ;
26919 PyObject * obj3 = 0 ;
26920 PyObject * obj4 = 0 ;
26921 char *kwnames[] = {
26922 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26923 };
26924
26925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26927 if (SWIG_arg_fail(1)) SWIG_fail;
26928 {
26929 arg2 = (int)(SWIG_As_int(obj1));
26930 if (SWIG_arg_fail(2)) SWIG_fail;
26931 }
26932 {
26933 arg3 = (int)(SWIG_As_int(obj2));
26934 if (SWIG_arg_fail(3)) SWIG_fail;
26935 }
26936 if (obj3) {
26937 {
26938 arg4 = (int)(SWIG_As_int(obj3));
26939 if (SWIG_arg_fail(4)) SWIG_fail;
26940 }
26941 }
26942 if (obj4) {
26943 {
26944 arg5 = (int)(SWIG_As_int(obj4));
26945 if (SWIG_arg_fail(5)) SWIG_fail;
26946 }
26947 }
26948 {
26949 PyThreadState* __tstate = wxPyBeginAllowThreads();
26950 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26951
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 Py_INCREF(Py_None); resultobj = Py_None;
26956 return resultobj;
26957 fail:
26958 return NULL;
26959 }
26960
26961
26962 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26963 PyObject *resultobj;
26964 wxWindow *arg1 = (wxWindow *) 0 ;
26965 wxSize *arg2 = 0 ;
26966 wxSize const &arg3_defvalue = wxDefaultSize ;
26967 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26968 wxSize temp2 ;
26969 wxSize temp3 ;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 PyObject * obj2 = 0 ;
26973 char *kwnames[] = {
26974 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26975 };
26976
26977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26979 if (SWIG_arg_fail(1)) SWIG_fail;
26980 {
26981 arg2 = &temp2;
26982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26983 }
26984 if (obj2) {
26985 {
26986 arg3 = &temp3;
26987 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26988 }
26989 }
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26993
26994 wxPyEndAllowThreads(__tstate);
26995 if (PyErr_Occurred()) SWIG_fail;
26996 }
26997 Py_INCREF(Py_None); resultobj = Py_None;
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj;
27006 wxWindow *arg1 = (wxWindow *) 0 ;
27007 wxSize result;
27008 PyObject * obj0 = 0 ;
27009 char *kwnames[] = {
27010 (char *) "self", NULL
27011 };
27012
27013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27015 if (SWIG_arg_fail(1)) SWIG_fail;
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 result = ((wxWindow const *)arg1)->GetMaxSize();
27019
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 {
27024 wxSize * resultptr;
27025 resultptr = new wxSize((wxSize &)(result));
27026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27027 }
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27035 PyObject *resultobj;
27036 wxWindow *arg1 = (wxWindow *) 0 ;
27037 wxSize result;
27038 PyObject * obj0 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = ((wxWindow const *)arg1)->GetMinSize();
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 {
27054 wxSize * resultptr;
27055 resultptr = new wxSize((wxSize &)(result));
27056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27057 }
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxWindow *arg1 = (wxWindow *) 0 ;
27067 wxSize *arg2 = 0 ;
27068 wxSize temp2 ;
27069 PyObject * obj0 = 0 ;
27070 PyObject * obj1 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self",(char *) "minSize", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 {
27079 arg2 = &temp2;
27080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27081 }
27082 {
27083 PyThreadState* __tstate = wxPyBeginAllowThreads();
27084 (arg1)->SetMinSize((wxSize const &)*arg2);
27085
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 Py_INCREF(Py_None); resultobj = Py_None;
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 wxSize *arg2 = 0 ;
27100 wxSize temp2 ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 char *kwnames[] = {
27104 (char *) "self",(char *) "maxSize", NULL
27105 };
27106
27107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27109 if (SWIG_arg_fail(1)) SWIG_fail;
27110 {
27111 arg2 = &temp2;
27112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27113 }
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 (arg1)->SetMaxSize((wxSize const &)*arg2);
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 Py_INCREF(Py_None); resultobj = Py_None;
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxWindow *arg1 = (wxWindow *) 0 ;
27131 int result;
27132 PyObject * obj0 = 0 ;
27133 char *kwnames[] = {
27134 (char *) "self", NULL
27135 };
27136
27137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27139 if (SWIG_arg_fail(1)) SWIG_fail;
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27143
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 {
27148 resultobj = SWIG_From_int((int)(result));
27149 }
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj;
27158 wxWindow *arg1 = (wxWindow *) 0 ;
27159 int result;
27160 PyObject * obj0 = 0 ;
27161 char *kwnames[] = {
27162 (char *) "self", NULL
27163 };
27164
27165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27167 if (SWIG_arg_fail(1)) SWIG_fail;
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27171
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = SWIG_From_int((int)(result));
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxWindow *arg1 = (wxWindow *) 0 ;
27187 int result;
27188 PyObject * obj0 = 0 ;
27189 char *kwnames[] = {
27190 (char *) "self", NULL
27191 };
27192
27193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27195 if (SWIG_arg_fail(1)) SWIG_fail;
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 resultobj = SWIG_From_int((int)(result));
27205 }
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj;
27214 wxWindow *arg1 = (wxWindow *) 0 ;
27215 int result;
27216 PyObject * obj0 = 0 ;
27217 char *kwnames[] = {
27218 (char *) "self", NULL
27219 };
27220
27221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27223 if (SWIG_arg_fail(1)) SWIG_fail;
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27227
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = SWIG_From_int((int)(result));
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj;
27242 wxWindow *arg1 = (wxWindow *) 0 ;
27243 wxSize *arg2 = 0 ;
27244 wxSize temp2 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char *kwnames[] = {
27248 (char *) "self",(char *) "size", NULL
27249 };
27250
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
27256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27257 }
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27261
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 Py_INCREF(Py_None); resultobj = Py_None;
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27273 PyObject *resultobj;
27274 wxWindow *arg1 = (wxWindow *) 0 ;
27275 int arg2 ;
27276 int arg3 ;
27277 PyObject * obj0 = 0 ;
27278 PyObject * obj1 = 0 ;
27279 PyObject * obj2 = 0 ;
27280 char *kwnames[] = {
27281 (char *) "self",(char *) "w",(char *) "h", NULL
27282 };
27283
27284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27286 if (SWIG_arg_fail(1)) SWIG_fail;
27287 {
27288 arg2 = (int)(SWIG_As_int(obj1));
27289 if (SWIG_arg_fail(2)) SWIG_fail;
27290 }
27291 {
27292 arg3 = (int)(SWIG_As_int(obj2));
27293 if (SWIG_arg_fail(3)) SWIG_fail;
27294 }
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->SetVirtualSize(arg2,arg3);
27298
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 Py_INCREF(Py_None); resultobj = Py_None;
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 wxSize result;
27313 PyObject * obj0 = 0 ;
27314 char *kwnames[] = {
27315 (char *) "self", NULL
27316 };
27317
27318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27320 if (SWIG_arg_fail(1)) SWIG_fail;
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = ((wxWindow const *)arg1)->GetVirtualSize();
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 {
27329 wxSize * resultptr;
27330 resultptr = new wxSize((wxSize &)(result));
27331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27332 }
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxWindow *arg1 = (wxWindow *) 0 ;
27342 int *arg2 = (int *) 0 ;
27343 int *arg3 = (int *) 0 ;
27344 int temp2 ;
27345 int res2 = 0 ;
27346 int temp3 ;
27347 int res3 = 0 ;
27348 PyObject * obj0 = 0 ;
27349 char *kwnames[] = {
27350 (char *) "self", NULL
27351 };
27352
27353 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27354 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27357 if (SWIG_arg_fail(1)) SWIG_fail;
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27361
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 Py_INCREF(Py_None); resultobj = Py_None;
27366 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27367 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27368 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27369 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27370 return resultobj;
27371 fail:
27372 return NULL;
27373 }
27374
27375
27376 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27377 PyObject *resultobj;
27378 wxWindow *arg1 = (wxWindow *) 0 ;
27379 wxSize result;
27380 PyObject * obj0 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27391
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 {
27396 wxSize * resultptr;
27397 resultptr = new wxSize((wxSize &)(result));
27398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27399 }
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj;
27408 wxWindow *arg1 = (wxWindow *) 0 ;
27409 bool arg2 = (bool) true ;
27410 bool result;
27411 PyObject * obj0 = 0 ;
27412 PyObject * obj1 = 0 ;
27413 char *kwnames[] = {
27414 (char *) "self",(char *) "show", NULL
27415 };
27416
27417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27419 if (SWIG_arg_fail(1)) SWIG_fail;
27420 if (obj1) {
27421 {
27422 arg2 = (bool)(SWIG_As_bool(obj1));
27423 if (SWIG_arg_fail(2)) SWIG_fail;
27424 }
27425 }
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = (bool)(arg1)->Show(arg2);
27429
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj;
27444 wxWindow *arg1 = (wxWindow *) 0 ;
27445 bool result;
27446 PyObject * obj0 = 0 ;
27447 char *kwnames[] = {
27448 (char *) "self", NULL
27449 };
27450
27451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27453 if (SWIG_arg_fail(1)) SWIG_fail;
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = (bool)(arg1)->Hide();
27457
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj;
27472 wxWindow *arg1 = (wxWindow *) 0 ;
27473 bool arg2 = (bool) true ;
27474 bool result;
27475 PyObject * obj0 = 0 ;
27476 PyObject * obj1 = 0 ;
27477 char *kwnames[] = {
27478 (char *) "self",(char *) "enable", NULL
27479 };
27480
27481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27483 if (SWIG_arg_fail(1)) SWIG_fail;
27484 if (obj1) {
27485 {
27486 arg2 = (bool)(SWIG_As_bool(obj1));
27487 if (SWIG_arg_fail(2)) SWIG_fail;
27488 }
27489 }
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (bool)(arg1)->Enable(arg2);
27493
27494 wxPyEndAllowThreads(__tstate);
27495 if (PyErr_Occurred()) SWIG_fail;
27496 }
27497 {
27498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27499 }
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27507 PyObject *resultobj;
27508 wxWindow *arg1 = (wxWindow *) 0 ;
27509 bool result;
27510 PyObject * obj0 = 0 ;
27511 char *kwnames[] = {
27512 (char *) "self", NULL
27513 };
27514
27515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(1)) SWIG_fail;
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 result = (bool)(arg1)->Disable();
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 {
27526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27527 }
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 bool result;
27538 PyObject * obj0 = 0 ;
27539 char *kwnames[] = {
27540 (char *) "self", NULL
27541 };
27542
27543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 {
27547 PyThreadState* __tstate = wxPyBeginAllowThreads();
27548 result = (bool)((wxWindow const *)arg1)->IsShown();
27549
27550 wxPyEndAllowThreads(__tstate);
27551 if (PyErr_Occurred()) SWIG_fail;
27552 }
27553 {
27554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27555 }
27556 return resultobj;
27557 fail:
27558 return NULL;
27559 }
27560
27561
27562 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27563 PyObject *resultobj;
27564 wxWindow *arg1 = (wxWindow *) 0 ;
27565 bool result;
27566 PyObject * obj0 = 0 ;
27567 char *kwnames[] = {
27568 (char *) "self", NULL
27569 };
27570
27571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27573 if (SWIG_arg_fail(1)) SWIG_fail;
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27577
27578 wxPyEndAllowThreads(__tstate);
27579 if (PyErr_Occurred()) SWIG_fail;
27580 }
27581 {
27582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27583 }
27584 return resultobj;
27585 fail:
27586 return NULL;
27587 }
27588
27589
27590 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27591 PyObject *resultobj;
27592 wxWindow *arg1 = (wxWindow *) 0 ;
27593 long arg2 ;
27594 PyObject * obj0 = 0 ;
27595 PyObject * obj1 = 0 ;
27596 char *kwnames[] = {
27597 (char *) "self",(char *) "style", NULL
27598 };
27599
27600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27602 if (SWIG_arg_fail(1)) SWIG_fail;
27603 {
27604 arg2 = (long)(SWIG_As_long(obj1));
27605 if (SWIG_arg_fail(2)) SWIG_fail;
27606 }
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 (arg1)->SetWindowStyleFlag(arg2);
27610
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 Py_INCREF(Py_None); resultobj = Py_None;
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27622 PyObject *resultobj;
27623 wxWindow *arg1 = (wxWindow *) 0 ;
27624 long result;
27625 PyObject * obj0 = 0 ;
27626 char *kwnames[] = {
27627 (char *) "self", NULL
27628 };
27629
27630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27632 if (SWIG_arg_fail(1)) SWIG_fail;
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27636
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 {
27641 resultobj = SWIG_From_long((long)(result));
27642 }
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj;
27651 wxWindow *arg1 = (wxWindow *) 0 ;
27652 int arg2 ;
27653 bool result;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 char *kwnames[] = {
27657 (char *) "self",(char *) "flag", NULL
27658 };
27659
27660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27662 if (SWIG_arg_fail(1)) SWIG_fail;
27663 {
27664 arg2 = (int)(SWIG_As_int(obj1));
27665 if (SWIG_arg_fail(2)) SWIG_fail;
27666 }
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27670
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 {
27675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27676 }
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27684 PyObject *resultobj;
27685 wxWindow *arg1 = (wxWindow *) 0 ;
27686 bool result;
27687 PyObject * obj0 = 0 ;
27688 char *kwnames[] = {
27689 (char *) "self", NULL
27690 };
27691
27692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27694 if (SWIG_arg_fail(1)) SWIG_fail;
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 result = (bool)((wxWindow const *)arg1)->IsRetained();
27698
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 {
27703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27704 }
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj;
27713 wxWindow *arg1 = (wxWindow *) 0 ;
27714 long arg2 ;
27715 PyObject * obj0 = 0 ;
27716 PyObject * obj1 = 0 ;
27717 char *kwnames[] = {
27718 (char *) "self",(char *) "exStyle", NULL
27719 };
27720
27721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27723 if (SWIG_arg_fail(1)) SWIG_fail;
27724 {
27725 arg2 = (long)(SWIG_As_long(obj1));
27726 if (SWIG_arg_fail(2)) SWIG_fail;
27727 }
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->SetExtraStyle(arg2);
27731
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 Py_INCREF(Py_None); resultobj = Py_None;
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27743 PyObject *resultobj;
27744 wxWindow *arg1 = (wxWindow *) 0 ;
27745 long result;
27746 PyObject * obj0 = 0 ;
27747 char *kwnames[] = {
27748 (char *) "self", NULL
27749 };
27750
27751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27753 if (SWIG_arg_fail(1)) SWIG_fail;
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27757
27758 wxPyEndAllowThreads(__tstate);
27759 if (PyErr_Occurred()) SWIG_fail;
27760 }
27761 {
27762 resultobj = SWIG_From_long((long)(result));
27763 }
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27771 PyObject *resultobj;
27772 wxWindow *arg1 = (wxWindow *) 0 ;
27773 bool arg2 = (bool) true ;
27774 PyObject * obj0 = 0 ;
27775 PyObject * obj1 = 0 ;
27776 char *kwnames[] = {
27777 (char *) "self",(char *) "modal", NULL
27778 };
27779
27780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27782 if (SWIG_arg_fail(1)) SWIG_fail;
27783 if (obj1) {
27784 {
27785 arg2 = (bool)(SWIG_As_bool(obj1));
27786 if (SWIG_arg_fail(2)) SWIG_fail;
27787 }
27788 }
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 (arg1)->MakeModal(arg2);
27792
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 Py_INCREF(Py_None); resultobj = Py_None;
27797 return resultobj;
27798 fail:
27799 return NULL;
27800 }
27801
27802
27803 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27804 PyObject *resultobj;
27805 wxWindow *arg1 = (wxWindow *) 0 ;
27806 bool arg2 ;
27807 PyObject * obj0 = 0 ;
27808 PyObject * obj1 = 0 ;
27809 char *kwnames[] = {
27810 (char *) "self",(char *) "enableTheme", NULL
27811 };
27812
27813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27815 if (SWIG_arg_fail(1)) SWIG_fail;
27816 {
27817 arg2 = (bool)(SWIG_As_bool(obj1));
27818 if (SWIG_arg_fail(2)) SWIG_fail;
27819 }
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->SetThemeEnabled(arg2);
27823
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 Py_INCREF(Py_None); resultobj = Py_None;
27828 return resultobj;
27829 fail:
27830 return NULL;
27831 }
27832
27833
27834 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27835 PyObject *resultobj;
27836 wxWindow *arg1 = (wxWindow *) 0 ;
27837 bool result;
27838 PyObject * obj0 = 0 ;
27839 char *kwnames[] = {
27840 (char *) "self", NULL
27841 };
27842
27843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27845 if (SWIG_arg_fail(1)) SWIG_fail;
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27849
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj;
27864 wxWindow *arg1 = (wxWindow *) 0 ;
27865 PyObject * obj0 = 0 ;
27866 char *kwnames[] = {
27867 (char *) "self", NULL
27868 };
27869
27870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27872 if (SWIG_arg_fail(1)) SWIG_fail;
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 (arg1)->SetFocus();
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 Py_INCREF(Py_None); resultobj = Py_None;
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj;
27889 wxWindow *arg1 = (wxWindow *) 0 ;
27890 PyObject * obj0 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 (arg1)->SetFocusFromKbd();
27901
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 Py_INCREF(Py_None); resultobj = Py_None;
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj;
27914 wxWindow *result;
27915 char *kwnames[] = {
27916 NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27920 {
27921 if (!wxPyCheckForApp()) SWIG_fail;
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 result = (wxWindow *)wxWindow::FindFocus();
27924
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 {
27929 resultobj = wxPyMake_wxObject(result, 0);
27930 }
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj;
27939 wxWindow *arg1 = (wxWindow *) 0 ;
27940 bool result;
27941 PyObject * obj0 = 0 ;
27942 char *kwnames[] = {
27943 (char *) "self", NULL
27944 };
27945
27946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27948 if (SWIG_arg_fail(1)) SWIG_fail;
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27958 }
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 bool result;
27969 PyObject * obj0 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(1)) SWIG_fail;
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27980
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 {
27985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27986 }
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 wxWindow *result;
27997 PyObject * obj0 = 0 ;
27998 char *kwnames[] = {
27999 (char *) "self", NULL
28000 };
28001
28002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28004 if (SWIG_arg_fail(1)) SWIG_fail;
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28008
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = wxPyMake_wxObject(result, 0);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj;
28023 wxWindow *arg1 = (wxWindow *) 0 ;
28024 wxWindow *arg2 = (wxWindow *) 0 ;
28025 wxWindow *result;
28026 PyObject * obj0 = 0 ;
28027 PyObject * obj1 = 0 ;
28028 char *kwnames[] = {
28029 (char *) "self",(char *) "child", NULL
28030 };
28031
28032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28034 if (SWIG_arg_fail(1)) SWIG_fail;
28035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28036 if (SWIG_arg_fail(2)) SWIG_fail;
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28040
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = wxPyMake_wxObject(result, 0);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28054 PyObject *resultobj;
28055 wxWindow *arg1 = (wxWindow *) 0 ;
28056 wxWindow *arg2 = (wxWindow *) 0 ;
28057 PyObject * obj0 = 0 ;
28058 PyObject * obj1 = 0 ;
28059 char *kwnames[] = {
28060 (char *) "self",(char *) "win", NULL
28061 };
28062
28063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28065 if (SWIG_arg_fail(1)) SWIG_fail;
28066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(2)) SWIG_fail;
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 (arg1)->SetTmpDefaultItem(arg2);
28071
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 Py_INCREF(Py_None); resultobj = Py_None;
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj;
28084 wxWindow *arg1 = (wxWindow *) 0 ;
28085 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28086 bool result;
28087 PyObject * obj0 = 0 ;
28088 PyObject * obj1 = 0 ;
28089 char *kwnames[] = {
28090 (char *) "self",(char *) "flags", NULL
28091 };
28092
28093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28095 if (SWIG_arg_fail(1)) SWIG_fail;
28096 if (obj1) {
28097 {
28098 arg2 = (int)(SWIG_As_int(obj1));
28099 if (SWIG_arg_fail(2)) SWIG_fail;
28100 }
28101 }
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 result = (bool)(arg1)->Navigate(arg2);
28105
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 {
28110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28111 }
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj;
28120 wxWindow *arg1 = (wxWindow *) 0 ;
28121 wxWindow *arg2 = (wxWindow *) 0 ;
28122 PyObject * obj0 = 0 ;
28123 PyObject * obj1 = 0 ;
28124 char *kwnames[] = {
28125 (char *) "self",(char *) "win", NULL
28126 };
28127
28128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28130 if (SWIG_arg_fail(1)) SWIG_fail;
28131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28132 if (SWIG_arg_fail(2)) SWIG_fail;
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 (arg1)->MoveAfterInTabOrder(arg2);
28136
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 Py_INCREF(Py_None); resultobj = Py_None;
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj;
28149 wxWindow *arg1 = (wxWindow *) 0 ;
28150 wxWindow *arg2 = (wxWindow *) 0 ;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 char *kwnames[] = {
28154 (char *) "self",(char *) "win", NULL
28155 };
28156
28157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28159 if (SWIG_arg_fail(1)) SWIG_fail;
28160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(2)) SWIG_fail;
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 (arg1)->MoveBeforeInTabOrder(arg2);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 Py_INCREF(Py_None); resultobj = Py_None;
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj;
28178 wxWindow *arg1 = (wxWindow *) 0 ;
28179 PyObject *result;
28180 PyObject * obj0 = 0 ;
28181 char *kwnames[] = {
28182 (char *) "self", NULL
28183 };
28184
28185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28187 if (SWIG_arg_fail(1)) SWIG_fail;
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (PyObject *)wxWindow_GetChildren(arg1);
28191
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = result;
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj;
28204 wxWindow *arg1 = (wxWindow *) 0 ;
28205 wxWindow *result;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 resultobj = wxPyMake_wxObject(result, 0);
28223 }
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj;
28232 wxWindow *arg1 = (wxWindow *) 0 ;
28233 wxWindow *result;
28234 PyObject * obj0 = 0 ;
28235 char *kwnames[] = {
28236 (char *) "self", NULL
28237 };
28238
28239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28241 if (SWIG_arg_fail(1)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28245
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 {
28250 resultobj = wxPyMake_wxObject(result, 0);
28251 }
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj;
28260 wxWindow *arg1 = (wxWindow *) 0 ;
28261 bool result;
28262 PyObject * obj0 = 0 ;
28263 char *kwnames[] = {
28264 (char *) "self", NULL
28265 };
28266
28267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28269 if (SWIG_arg_fail(1)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28273
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 {
28278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28279 }
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj;
28288 wxWindow *arg1 = (wxWindow *) 0 ;
28289 wxWindow *arg2 = (wxWindow *) 0 ;
28290 bool result;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char *kwnames[] = {
28294 (char *) "self",(char *) "newParent", NULL
28295 };
28296
28297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28299 if (SWIG_arg_fail(1)) SWIG_fail;
28300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28301 if (SWIG_arg_fail(2)) SWIG_fail;
28302 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 result = (bool)(arg1)->Reparent(arg2);
28305
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 {
28310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28311 }
28312 return resultobj;
28313 fail:
28314 return NULL;
28315 }
28316
28317
28318 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28319 PyObject *resultobj;
28320 wxWindow *arg1 = (wxWindow *) 0 ;
28321 wxWindow *arg2 = (wxWindow *) 0 ;
28322 PyObject * obj0 = 0 ;
28323 PyObject * obj1 = 0 ;
28324 char *kwnames[] = {
28325 (char *) "self",(char *) "child", NULL
28326 };
28327
28328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28330 if (SWIG_arg_fail(1)) SWIG_fail;
28331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28332 if (SWIG_arg_fail(2)) SWIG_fail;
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 (arg1)->AddChild(arg2);
28336
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 Py_INCREF(Py_None); resultobj = Py_None;
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj;
28349 wxWindow *arg1 = (wxWindow *) 0 ;
28350 wxWindow *arg2 = (wxWindow *) 0 ;
28351 PyObject * obj0 = 0 ;
28352 PyObject * obj1 = 0 ;
28353 char *kwnames[] = {
28354 (char *) "self",(char *) "child", NULL
28355 };
28356
28357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28359 if (SWIG_arg_fail(1)) SWIG_fail;
28360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28361 if (SWIG_arg_fail(2)) SWIG_fail;
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 (arg1)->RemoveChild(arg2);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 Py_INCREF(Py_None); resultobj = Py_None;
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28377 PyObject *resultobj;
28378 wxWindow *arg1 = (wxWindow *) 0 ;
28379 long arg2 ;
28380 wxWindow *result;
28381 PyObject * obj0 = 0 ;
28382 PyObject * obj1 = 0 ;
28383 char *kwnames[] = {
28384 (char *) "self",(char *) "winid", NULL
28385 };
28386
28387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28389 if (SWIG_arg_fail(1)) SWIG_fail;
28390 {
28391 arg2 = (long)(SWIG_As_long(obj1));
28392 if (SWIG_arg_fail(2)) SWIG_fail;
28393 }
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (wxWindow *)(arg1)->FindWindow(arg2);
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = wxPyMake_wxObject(result, 0);
28403 }
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxWindow *arg1 = (wxWindow *) 0 ;
28413 wxString *arg2 = 0 ;
28414 wxWindow *result;
28415 bool temp2 = false ;
28416 PyObject * obj0 = 0 ;
28417 PyObject * obj1 = 0 ;
28418 char *kwnames[] = {
28419 (char *) "self",(char *) "name", NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28424 if (SWIG_arg_fail(1)) SWIG_fail;
28425 {
28426 arg2 = wxString_in_helper(obj1);
28427 if (arg2 == NULL) SWIG_fail;
28428 temp2 = true;
28429 }
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 resultobj = wxPyMake_wxObject(result, 0);
28439 }
28440 {
28441 if (temp2)
28442 delete arg2;
28443 }
28444 return resultobj;
28445 fail:
28446 {
28447 if (temp2)
28448 delete arg2;
28449 }
28450 return NULL;
28451 }
28452
28453
28454 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj;
28456 wxWindow *arg1 = (wxWindow *) 0 ;
28457 wxEvtHandler *result;
28458 PyObject * obj0 = 0 ;
28459 char *kwnames[] = {
28460 (char *) "self", NULL
28461 };
28462
28463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28465 if (SWIG_arg_fail(1)) SWIG_fail;
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28469
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 {
28474 resultobj = wxPyMake_wxObject(result, 0);
28475 }
28476 return resultobj;
28477 fail:
28478 return NULL;
28479 }
28480
28481
28482 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28483 PyObject *resultobj;
28484 wxWindow *arg1 = (wxWindow *) 0 ;
28485 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28486 PyObject * obj0 = 0 ;
28487 PyObject * obj1 = 0 ;
28488 char *kwnames[] = {
28489 (char *) "self",(char *) "handler", NULL
28490 };
28491
28492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28494 if (SWIG_arg_fail(1)) SWIG_fail;
28495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28496 if (SWIG_arg_fail(2)) SWIG_fail;
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->SetEventHandler(arg2);
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 Py_INCREF(Py_None); resultobj = Py_None;
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28512 PyObject *resultobj;
28513 wxWindow *arg1 = (wxWindow *) 0 ;
28514 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 char *kwnames[] = {
28518 (char *) "self",(char *) "handler", NULL
28519 };
28520
28521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(1)) SWIG_fail;
28524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 (arg1)->PushEventHandler(arg2);
28529
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 Py_INCREF(Py_None); resultobj = Py_None;
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxWindow *arg1 = (wxWindow *) 0 ;
28543 bool arg2 = (bool) false ;
28544 wxEvtHandler *result;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "deleteHandler", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 if (obj1) {
28555 {
28556 arg2 = (bool)(SWIG_As_bool(obj1));
28557 if (SWIG_arg_fail(2)) SWIG_fail;
28558 }
28559 }
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28563
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 {
28568 resultobj = wxPyMake_wxObject(result, 0);
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxWindow *arg1 = (wxWindow *) 0 ;
28579 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28580 bool result;
28581 PyObject * obj0 = 0 ;
28582 PyObject * obj1 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "handler", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(2)) SWIG_fail;
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = (bool)(arg1)->RemoveEventHandler(arg2);
28595
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 {
28600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28601 }
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28609 PyObject *resultobj;
28610 wxWindow *arg1 = (wxWindow *) 0 ;
28611 wxValidator *arg2 = 0 ;
28612 PyObject * obj0 = 0 ;
28613 PyObject * obj1 = 0 ;
28614 char *kwnames[] = {
28615 (char *) "self",(char *) "validator", NULL
28616 };
28617
28618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28620 if (SWIG_arg_fail(1)) SWIG_fail;
28621 {
28622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28623 if (SWIG_arg_fail(2)) SWIG_fail;
28624 if (arg2 == NULL) {
28625 SWIG_null_ref("wxValidator");
28626 }
28627 if (SWIG_arg_fail(2)) SWIG_fail;
28628 }
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 (arg1)->SetValidator((wxValidator const &)*arg2);
28632
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 Py_INCREF(Py_None); resultobj = Py_None;
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxWindow *arg1 = (wxWindow *) 0 ;
28646 wxValidator *result;
28647 PyObject * obj0 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = (wxValidator *)(arg1)->GetValidator();
28658
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 {
28663 resultobj = wxPyMake_wxObject(result, 0);
28664 }
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj;
28673 wxWindow *arg1 = (wxWindow *) 0 ;
28674 bool result;
28675 PyObject * obj0 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (bool)(arg1)->Validate();
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj;
28701 wxWindow *arg1 = (wxWindow *) 0 ;
28702 bool result;
28703 PyObject * obj0 = 0 ;
28704 char *kwnames[] = {
28705 (char *) "self", NULL
28706 };
28707
28708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28710 if (SWIG_arg_fail(1)) SWIG_fail;
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 result = (bool)(arg1)->TransferDataToWindow();
28714
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 {
28719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28720 }
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28728 PyObject *resultobj;
28729 wxWindow *arg1 = (wxWindow *) 0 ;
28730 bool result;
28731 PyObject * obj0 = 0 ;
28732 char *kwnames[] = {
28733 (char *) "self", NULL
28734 };
28735
28736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28738 if (SWIG_arg_fail(1)) SWIG_fail;
28739 {
28740 PyThreadState* __tstate = wxPyBeginAllowThreads();
28741 result = (bool)(arg1)->TransferDataFromWindow();
28742
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 {
28747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28748 }
28749 return resultobj;
28750 fail:
28751 return NULL;
28752 }
28753
28754
28755 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28756 PyObject *resultobj;
28757 wxWindow *arg1 = (wxWindow *) 0 ;
28758 PyObject * obj0 = 0 ;
28759 char *kwnames[] = {
28760 (char *) "self", NULL
28761 };
28762
28763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28765 if (SWIG_arg_fail(1)) SWIG_fail;
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->InitDialog();
28769
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 Py_INCREF(Py_None); resultobj = Py_None;
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj;
28782 wxWindow *arg1 = (wxWindow *) 0 ;
28783 wxAcceleratorTable *arg2 = 0 ;
28784 PyObject * obj0 = 0 ;
28785 PyObject * obj1 = 0 ;
28786 char *kwnames[] = {
28787 (char *) "self",(char *) "accel", NULL
28788 };
28789
28790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28792 if (SWIG_arg_fail(1)) SWIG_fail;
28793 {
28794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28795 if (SWIG_arg_fail(2)) SWIG_fail;
28796 if (arg2 == NULL) {
28797 SWIG_null_ref("wxAcceleratorTable");
28798 }
28799 if (SWIG_arg_fail(2)) SWIG_fail;
28800 }
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28804
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 Py_INCREF(Py_None); resultobj = Py_None;
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28816 PyObject *resultobj;
28817 wxWindow *arg1 = (wxWindow *) 0 ;
28818 wxAcceleratorTable *result;
28819 PyObject * obj0 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28826 if (SWIG_arg_fail(1)) SWIG_fail;
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28830
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj;
28843 wxWindow *arg1 = (wxWindow *) 0 ;
28844 int arg2 ;
28845 int arg3 ;
28846 int arg4 ;
28847 bool result;
28848 PyObject * obj0 = 0 ;
28849 PyObject * obj1 = 0 ;
28850 PyObject * obj2 = 0 ;
28851 PyObject * obj3 = 0 ;
28852 char *kwnames[] = {
28853 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28854 };
28855
28856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28858 if (SWIG_arg_fail(1)) SWIG_fail;
28859 {
28860 arg2 = (int)(SWIG_As_int(obj1));
28861 if (SWIG_arg_fail(2)) SWIG_fail;
28862 }
28863 {
28864 arg3 = (int)(SWIG_As_int(obj2));
28865 if (SWIG_arg_fail(3)) SWIG_fail;
28866 }
28867 {
28868 arg4 = (int)(SWIG_As_int(obj3));
28869 if (SWIG_arg_fail(4)) SWIG_fail;
28870 }
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 {
28879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28880 }
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj;
28889 wxWindow *arg1 = (wxWindow *) 0 ;
28890 int arg2 ;
28891 bool result;
28892 PyObject * obj0 = 0 ;
28893 PyObject * obj1 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "self",(char *) "hotkeyId", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 {
28902 arg2 = (int)(SWIG_As_int(obj1));
28903 if (SWIG_arg_fail(2)) SWIG_fail;
28904 }
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28908
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 {
28913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28914 }
28915 return resultobj;
28916 fail:
28917 return NULL;
28918 }
28919
28920
28921 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28922 PyObject *resultobj;
28923 wxWindow *arg1 = (wxWindow *) 0 ;
28924 wxPoint *arg2 = 0 ;
28925 wxPoint result;
28926 wxPoint temp2 ;
28927 PyObject * obj0 = 0 ;
28928 PyObject * obj1 = 0 ;
28929 char *kwnames[] = {
28930 (char *) "self",(char *) "pt", NULL
28931 };
28932
28933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28935 if (SWIG_arg_fail(1)) SWIG_fail;
28936 {
28937 arg2 = &temp2;
28938 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28939 }
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28943
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 {
28948 wxPoint * resultptr;
28949 resultptr = new wxPoint((wxPoint &)(result));
28950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28951 }
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28959 PyObject *resultobj;
28960 wxWindow *arg1 = (wxWindow *) 0 ;
28961 wxSize *arg2 = 0 ;
28962 wxSize result;
28963 wxSize temp2 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 char *kwnames[] = {
28967 (char *) "self",(char *) "sz", NULL
28968 };
28969
28970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(1)) SWIG_fail;
28973 {
28974 arg2 = &temp2;
28975 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28980
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 {
28985 wxSize * resultptr;
28986 resultptr = new wxSize((wxSize &)(result));
28987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28988 }
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj;
28997 wxWindow *arg1 = (wxWindow *) 0 ;
28998 wxPoint *arg2 = 0 ;
28999 wxPoint result;
29000 wxPoint temp2 ;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 char *kwnames[] = {
29004 (char *) "self",(char *) "pt", NULL
29005 };
29006
29007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29009 if (SWIG_arg_fail(1)) SWIG_fail;
29010 {
29011 arg2 = &temp2;
29012 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29013 }
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29017
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 {
29022 wxPoint * resultptr;
29023 resultptr = new wxPoint((wxPoint &)(result));
29024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29025 }
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxWindow *arg1 = (wxWindow *) 0 ;
29035 wxSize *arg2 = 0 ;
29036 wxSize result;
29037 wxSize temp2 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char *kwnames[] = {
29041 (char *) "self",(char *) "sz", NULL
29042 };
29043
29044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29046 if (SWIG_arg_fail(1)) SWIG_fail;
29047 {
29048 arg2 = &temp2;
29049 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29050 }
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29054
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 {
29059 wxSize * resultptr;
29060 resultptr = new wxSize((wxSize &)(result));
29061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29062 }
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29070 PyObject *resultobj;
29071 wxWindow *arg1 = (wxWindow *) 0 ;
29072 wxPoint *arg2 = 0 ;
29073 wxPoint result;
29074 wxPoint temp2 ;
29075 PyObject * obj0 = 0 ;
29076 PyObject * obj1 = 0 ;
29077 char *kwnames[] = {
29078 (char *) "self",(char *) "pt", NULL
29079 };
29080
29081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29083 if (SWIG_arg_fail(1)) SWIG_fail;
29084 {
29085 arg2 = &temp2;
29086 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29087 }
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29091
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 {
29096 wxPoint * resultptr;
29097 resultptr = new wxPoint((wxPoint &)(result));
29098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29099 }
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29107 PyObject *resultobj;
29108 wxWindow *arg1 = (wxWindow *) 0 ;
29109 wxSize *arg2 = 0 ;
29110 wxSize result;
29111 wxSize temp2 ;
29112 PyObject * obj0 = 0 ;
29113 PyObject * obj1 = 0 ;
29114 char *kwnames[] = {
29115 (char *) "self",(char *) "sz", NULL
29116 };
29117
29118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29120 if (SWIG_arg_fail(1)) SWIG_fail;
29121 {
29122 arg2 = &temp2;
29123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29124 }
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29128
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 {
29133 wxSize * resultptr;
29134 resultptr = new wxSize((wxSize &)(result));
29135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29136 }
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29144 PyObject *resultobj;
29145 wxWindow *arg1 = (wxWindow *) 0 ;
29146 int arg2 ;
29147 int arg3 ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 PyObject * obj2 = 0 ;
29151 char *kwnames[] = {
29152 (char *) "self",(char *) "x",(char *) "y", NULL
29153 };
29154
29155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29157 if (SWIG_arg_fail(1)) SWIG_fail;
29158 {
29159 arg2 = (int)(SWIG_As_int(obj1));
29160 if (SWIG_arg_fail(2)) SWIG_fail;
29161 }
29162 {
29163 arg3 = (int)(SWIG_As_int(obj2));
29164 if (SWIG_arg_fail(3)) SWIG_fail;
29165 }
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 (arg1)->WarpPointer(arg2,arg3);
29169
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 Py_INCREF(Py_None); resultobj = Py_None;
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29181 PyObject *resultobj;
29182 wxWindow *arg1 = (wxWindow *) 0 ;
29183 PyObject * obj0 = 0 ;
29184 char *kwnames[] = {
29185 (char *) "self", NULL
29186 };
29187
29188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29190 if (SWIG_arg_fail(1)) SWIG_fail;
29191 {
29192 PyThreadState* __tstate = wxPyBeginAllowThreads();
29193 (arg1)->CaptureMouse();
29194
29195 wxPyEndAllowThreads(__tstate);
29196 if (PyErr_Occurred()) SWIG_fail;
29197 }
29198 Py_INCREF(Py_None); resultobj = Py_None;
29199 return resultobj;
29200 fail:
29201 return NULL;
29202 }
29203
29204
29205 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29206 PyObject *resultobj;
29207 wxWindow *arg1 = (wxWindow *) 0 ;
29208 PyObject * obj0 = 0 ;
29209 char *kwnames[] = {
29210 (char *) "self", NULL
29211 };
29212
29213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) 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 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 (arg1)->ReleaseMouse();
29219
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 Py_INCREF(Py_None); resultobj = Py_None;
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj;
29232 wxWindow *result;
29233 char *kwnames[] = {
29234 NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29238 {
29239 if (!wxPyCheckForApp()) SWIG_fail;
29240 PyThreadState* __tstate = wxPyBeginAllowThreads();
29241 result = (wxWindow *)wxWindow::GetCapture();
29242
29243 wxPyEndAllowThreads(__tstate);
29244 if (PyErr_Occurred()) SWIG_fail;
29245 }
29246 {
29247 resultobj = wxPyMake_wxObject(result, 0);
29248 }
29249 return resultobj;
29250 fail:
29251 return NULL;
29252 }
29253
29254
29255 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29256 PyObject *resultobj;
29257 wxWindow *arg1 = (wxWindow *) 0 ;
29258 bool result;
29259 PyObject * obj0 = 0 ;
29260 char *kwnames[] = {
29261 (char *) "self", NULL
29262 };
29263
29264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29266 if (SWIG_arg_fail(1)) SWIG_fail;
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (bool)((wxWindow const *)arg1)->HasCapture();
29270
29271 wxPyEndAllowThreads(__tstate);
29272 if (PyErr_Occurred()) SWIG_fail;
29273 }
29274 {
29275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29276 }
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj;
29285 wxWindow *arg1 = (wxWindow *) 0 ;
29286 bool arg2 = (bool) true ;
29287 wxRect *arg3 = (wxRect *) NULL ;
29288 PyObject * obj0 = 0 ;
29289 PyObject * obj1 = 0 ;
29290 PyObject * obj2 = 0 ;
29291 char *kwnames[] = {
29292 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29293 };
29294
29295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29297 if (SWIG_arg_fail(1)) SWIG_fail;
29298 if (obj1) {
29299 {
29300 arg2 = (bool)(SWIG_As_bool(obj1));
29301 if (SWIG_arg_fail(2)) SWIG_fail;
29302 }
29303 }
29304 if (obj2) {
29305 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29306 if (SWIG_arg_fail(3)) SWIG_fail;
29307 }
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29311
29312 wxPyEndAllowThreads(__tstate);
29313 if (PyErr_Occurred()) SWIG_fail;
29314 }
29315 Py_INCREF(Py_None); resultobj = Py_None;
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj;
29324 wxWindow *arg1 = (wxWindow *) 0 ;
29325 wxRect *arg2 = 0 ;
29326 bool arg3 = (bool) true ;
29327 wxRect temp2 ;
29328 PyObject * obj0 = 0 ;
29329 PyObject * obj1 = 0 ;
29330 PyObject * obj2 = 0 ;
29331 char *kwnames[] = {
29332 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29333 };
29334
29335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29337 if (SWIG_arg_fail(1)) SWIG_fail;
29338 {
29339 arg2 = &temp2;
29340 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29341 }
29342 if (obj2) {
29343 {
29344 arg3 = (bool)(SWIG_As_bool(obj2));
29345 if (SWIG_arg_fail(3)) SWIG_fail;
29346 }
29347 }
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29351
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 Py_INCREF(Py_None); resultobj = Py_None;
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj;
29364 wxWindow *arg1 = (wxWindow *) 0 ;
29365 PyObject * obj0 = 0 ;
29366 char *kwnames[] = {
29367 (char *) "self", NULL
29368 };
29369
29370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29372 if (SWIG_arg_fail(1)) SWIG_fail;
29373 {
29374 PyThreadState* __tstate = wxPyBeginAllowThreads();
29375 (arg1)->Update();
29376
29377 wxPyEndAllowThreads(__tstate);
29378 if (PyErr_Occurred()) SWIG_fail;
29379 }
29380 Py_INCREF(Py_None); resultobj = Py_None;
29381 return resultobj;
29382 fail:
29383 return NULL;
29384 }
29385
29386
29387 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29388 PyObject *resultobj;
29389 wxWindow *arg1 = (wxWindow *) 0 ;
29390 PyObject * obj0 = 0 ;
29391 char *kwnames[] = {
29392 (char *) "self", NULL
29393 };
29394
29395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29397 if (SWIG_arg_fail(1)) SWIG_fail;
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 (arg1)->ClearBackground();
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 Py_INCREF(Py_None); resultobj = Py_None;
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29413 PyObject *resultobj;
29414 wxWindow *arg1 = (wxWindow *) 0 ;
29415 PyObject * obj0 = 0 ;
29416 char *kwnames[] = {
29417 (char *) "self", NULL
29418 };
29419
29420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29422 if (SWIG_arg_fail(1)) SWIG_fail;
29423 {
29424 PyThreadState* __tstate = wxPyBeginAllowThreads();
29425 (arg1)->Freeze();
29426
29427 wxPyEndAllowThreads(__tstate);
29428 if (PyErr_Occurred()) SWIG_fail;
29429 }
29430 Py_INCREF(Py_None); resultobj = Py_None;
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29438 PyObject *resultobj;
29439 wxWindow *arg1 = (wxWindow *) 0 ;
29440 PyObject * obj0 = 0 ;
29441 char *kwnames[] = {
29442 (char *) "self", NULL
29443 };
29444
29445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29447 if (SWIG_arg_fail(1)) SWIG_fail;
29448 {
29449 PyThreadState* __tstate = wxPyBeginAllowThreads();
29450 (arg1)->Thaw();
29451
29452 wxPyEndAllowThreads(__tstate);
29453 if (PyErr_Occurred()) SWIG_fail;
29454 }
29455 Py_INCREF(Py_None); resultobj = Py_None;
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj;
29464 wxWindow *arg1 = (wxWindow *) 0 ;
29465 wxDC *arg2 = 0 ;
29466 PyObject * obj0 = 0 ;
29467 PyObject * obj1 = 0 ;
29468 char *kwnames[] = {
29469 (char *) "self",(char *) "dc", NULL
29470 };
29471
29472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29474 if (SWIG_arg_fail(1)) SWIG_fail;
29475 {
29476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29477 if (SWIG_arg_fail(2)) SWIG_fail;
29478 if (arg2 == NULL) {
29479 SWIG_null_ref("wxDC");
29480 }
29481 if (SWIG_arg_fail(2)) SWIG_fail;
29482 }
29483 {
29484 PyThreadState* __tstate = wxPyBeginAllowThreads();
29485 (arg1)->PrepareDC(*arg2);
29486
29487 wxPyEndAllowThreads(__tstate);
29488 if (PyErr_Occurred()) SWIG_fail;
29489 }
29490 Py_INCREF(Py_None); resultobj = Py_None;
29491 return resultobj;
29492 fail:
29493 return NULL;
29494 }
29495
29496
29497 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29498 PyObject *resultobj;
29499 wxWindow *arg1 = (wxWindow *) 0 ;
29500 wxRegion *result;
29501 PyObject * obj0 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 {
29512 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29513 result = (wxRegion *) &_result_ref;
29514 }
29515
29516 wxPyEndAllowThreads(__tstate);
29517 if (PyErr_Occurred()) SWIG_fail;
29518 }
29519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29527 PyObject *resultobj;
29528 wxWindow *arg1 = (wxWindow *) 0 ;
29529 wxRect result;
29530 PyObject * obj0 = 0 ;
29531 char *kwnames[] = {
29532 (char *) "self", NULL
29533 };
29534
29535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29537 if (SWIG_arg_fail(1)) SWIG_fail;
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29541
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 {
29546 wxRect * resultptr;
29547 resultptr = new wxRect((wxRect &)(result));
29548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29549 }
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj;
29558 wxWindow *arg1 = (wxWindow *) 0 ;
29559 int arg2 ;
29560 int arg3 ;
29561 int arg4 = (int) 1 ;
29562 int arg5 = (int) 1 ;
29563 bool result;
29564 PyObject * obj0 = 0 ;
29565 PyObject * obj1 = 0 ;
29566 PyObject * obj2 = 0 ;
29567 PyObject * obj3 = 0 ;
29568 PyObject * obj4 = 0 ;
29569 char *kwnames[] = {
29570 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29571 };
29572
29573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29575 if (SWIG_arg_fail(1)) SWIG_fail;
29576 {
29577 arg2 = (int)(SWIG_As_int(obj1));
29578 if (SWIG_arg_fail(2)) SWIG_fail;
29579 }
29580 {
29581 arg3 = (int)(SWIG_As_int(obj2));
29582 if (SWIG_arg_fail(3)) SWIG_fail;
29583 }
29584 if (obj3) {
29585 {
29586 arg4 = (int)(SWIG_As_int(obj3));
29587 if (SWIG_arg_fail(4)) SWIG_fail;
29588 }
29589 }
29590 if (obj4) {
29591 {
29592 arg5 = (int)(SWIG_As_int(obj4));
29593 if (SWIG_arg_fail(5)) SWIG_fail;
29594 }
29595 }
29596 {
29597 PyThreadState* __tstate = wxPyBeginAllowThreads();
29598 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29599
29600 wxPyEndAllowThreads(__tstate);
29601 if (PyErr_Occurred()) SWIG_fail;
29602 }
29603 {
29604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29605 }
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxWindow *arg1 = (wxWindow *) 0 ;
29615 wxPoint *arg2 = 0 ;
29616 bool result;
29617 wxPoint temp2 ;
29618 PyObject * obj0 = 0 ;
29619 PyObject * obj1 = 0 ;
29620 char *kwnames[] = {
29621 (char *) "self",(char *) "pt", NULL
29622 };
29623
29624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29626 if (SWIG_arg_fail(1)) SWIG_fail;
29627 {
29628 arg2 = &temp2;
29629 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29630 }
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29634
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 {
29639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29640 }
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxWindow *arg1 = (wxWindow *) 0 ;
29650 wxRect *arg2 = 0 ;
29651 bool result;
29652 wxRect temp2 ;
29653 PyObject * obj0 = 0 ;
29654 PyObject * obj1 = 0 ;
29655 char *kwnames[] = {
29656 (char *) "self",(char *) "rect", NULL
29657 };
29658
29659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29661 if (SWIG_arg_fail(1)) SWIG_fail;
29662 {
29663 arg2 = &temp2;
29664 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29665 }
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29669
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 {
29674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29675 }
29676 return resultobj;
29677 fail:
29678 return NULL;
29679 }
29680
29681
29682 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29683 PyObject *resultobj;
29684 wxWindow *arg1 = (wxWindow *) 0 ;
29685 wxVisualAttributes result;
29686 PyObject * obj0 = 0 ;
29687 char *kwnames[] = {
29688 (char *) "self", NULL
29689 };
29690
29691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29697
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 {
29702 wxVisualAttributes * resultptr;
29703 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29705 }
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29713 PyObject *resultobj;
29714 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29715 wxVisualAttributes result;
29716 PyObject * obj0 = 0 ;
29717 char *kwnames[] = {
29718 (char *) "variant", NULL
29719 };
29720
29721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29722 if (obj0) {
29723 {
29724 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29725 if (SWIG_arg_fail(1)) SWIG_fail;
29726 }
29727 }
29728 {
29729 if (!wxPyCheckForApp()) SWIG_fail;
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 wxVisualAttributes * resultptr;
29738 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29739 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29740 }
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj;
29749 wxWindow *arg1 = (wxWindow *) 0 ;
29750 wxColour *arg2 = 0 ;
29751 bool result;
29752 wxColour temp2 ;
29753 PyObject * obj0 = 0 ;
29754 PyObject * obj1 = 0 ;
29755 char *kwnames[] = {
29756 (char *) "self",(char *) "colour", NULL
29757 };
29758
29759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(1)) SWIG_fail;
29762 {
29763 arg2 = &temp2;
29764 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29765 }
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 {
29774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29775 }
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxWindow *arg1 = (wxWindow *) 0 ;
29785 wxColour *arg2 = 0 ;
29786 wxColour temp2 ;
29787 PyObject * obj0 = 0 ;
29788 PyObject * obj1 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self",(char *) "colour", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 arg2 = &temp2;
29798 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29799 }
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 Py_INCREF(Py_None); resultobj = Py_None;
29808 return resultobj;
29809 fail:
29810 return NULL;
29811 }
29812
29813
29814 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29815 PyObject *resultobj;
29816 wxWindow *arg1 = (wxWindow *) 0 ;
29817 wxColour *arg2 = 0 ;
29818 bool result;
29819 wxColour temp2 ;
29820 PyObject * obj0 = 0 ;
29821 PyObject * obj1 = 0 ;
29822 char *kwnames[] = {
29823 (char *) "self",(char *) "colour", NULL
29824 };
29825
29826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29828 if (SWIG_arg_fail(1)) SWIG_fail;
29829 {
29830 arg2 = &temp2;
29831 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29832 }
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29836
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 {
29841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29842 }
29843 return resultobj;
29844 fail:
29845 return NULL;
29846 }
29847
29848
29849 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj;
29851 wxWindow *arg1 = (wxWindow *) 0 ;
29852 wxColour *arg2 = 0 ;
29853 wxColour temp2 ;
29854 PyObject * obj0 = 0 ;
29855 PyObject * obj1 = 0 ;
29856 char *kwnames[] = {
29857 (char *) "self",(char *) "colour", NULL
29858 };
29859
29860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29862 if (SWIG_arg_fail(1)) SWIG_fail;
29863 {
29864 arg2 = &temp2;
29865 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29866 }
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29870
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 Py_INCREF(Py_None); resultobj = Py_None;
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29882 PyObject *resultobj;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 wxColour result;
29885 PyObject * obj0 = 0 ;
29886 char *kwnames[] = {
29887 (char *) "self", NULL
29888 };
29889
29890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29892 if (SWIG_arg_fail(1)) SWIG_fail;
29893 {
29894 PyThreadState* __tstate = wxPyBeginAllowThreads();
29895 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29896
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 {
29901 wxColour * resultptr;
29902 resultptr = new wxColour((wxColour &)(result));
29903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29904 }
29905 return resultobj;
29906 fail:
29907 return NULL;
29908 }
29909
29910
29911 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29912 PyObject *resultobj;
29913 wxWindow *arg1 = (wxWindow *) 0 ;
29914 wxColour result;
29915 PyObject * obj0 = 0 ;
29916 char *kwnames[] = {
29917 (char *) "self", NULL
29918 };
29919
29920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29922 if (SWIG_arg_fail(1)) SWIG_fail;
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = ((wxWindow const *)arg1)->GetForegroundColour();
29926
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 {
29931 wxColour * resultptr;
29932 resultptr = new wxColour((wxColour &)(result));
29933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29934 }
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29942 PyObject *resultobj;
29943 wxWindow *arg1 = (wxWindow *) 0 ;
29944 bool result;
29945 PyObject * obj0 = 0 ;
29946 char *kwnames[] = {
29947 (char *) "self", NULL
29948 };
29949
29950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29952 if (SWIG_arg_fail(1)) SWIG_fail;
29953 {
29954 PyThreadState* __tstate = wxPyBeginAllowThreads();
29955 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29956
29957 wxPyEndAllowThreads(__tstate);
29958 if (PyErr_Occurred()) SWIG_fail;
29959 }
29960 {
29961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29962 }
29963 return resultobj;
29964 fail:
29965 return NULL;
29966 }
29967
29968
29969 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29970 PyObject *resultobj;
29971 wxWindow *arg1 = (wxWindow *) 0 ;
29972 bool result;
29973 PyObject * obj0 = 0 ;
29974 char *kwnames[] = {
29975 (char *) "self", NULL
29976 };
29977
29978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29980 if (SWIG_arg_fail(1)) SWIG_fail;
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29984
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 {
29989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29990 }
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj;
29999 wxWindow *arg1 = (wxWindow *) 0 ;
30000 wxBackgroundStyle arg2 ;
30001 bool result;
30002 PyObject * obj0 = 0 ;
30003 PyObject * obj1 = 0 ;
30004 char *kwnames[] = {
30005 (char *) "self",(char *) "style", NULL
30006 };
30007
30008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30010 if (SWIG_arg_fail(1)) SWIG_fail;
30011 {
30012 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30013 if (SWIG_arg_fail(2)) SWIG_fail;
30014 }
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30018
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 {
30023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj;
30033 wxWindow *arg1 = (wxWindow *) 0 ;
30034 wxBackgroundStyle result;
30035 PyObject * obj0 = 0 ;
30036 char *kwnames[] = {
30037 (char *) "self", NULL
30038 };
30039
30040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30042 if (SWIG_arg_fail(1)) SWIG_fail;
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30046
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 resultobj = SWIG_From_int((result));
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30058 PyObject *resultobj;
30059 wxWindow *arg1 = (wxWindow *) 0 ;
30060 bool result;
30061 PyObject * obj0 = 0 ;
30062 char *kwnames[] = {
30063 (char *) "self", NULL
30064 };
30065
30066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30068 if (SWIG_arg_fail(1)) SWIG_fail;
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 result = (bool)(arg1)->HasTransparentBackground();
30072
30073 wxPyEndAllowThreads(__tstate);
30074 if (PyErr_Occurred()) SWIG_fail;
30075 }
30076 {
30077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30078 }
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30086 PyObject *resultobj;
30087 wxWindow *arg1 = (wxWindow *) 0 ;
30088 wxCursor *arg2 = 0 ;
30089 bool result;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self",(char *) "cursor", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 if (arg2 == NULL) {
30103 SWIG_null_ref("wxCursor");
30104 }
30105 if (SWIG_arg_fail(2)) SWIG_fail;
30106 }
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30110
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 {
30115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30116 }
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30124 PyObject *resultobj;
30125 wxWindow *arg1 = (wxWindow *) 0 ;
30126 wxCursor result;
30127 PyObject * obj0 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "self", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(1)) SWIG_fail;
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (arg1)->GetCursor();
30138
30139 wxPyEndAllowThreads(__tstate);
30140 if (PyErr_Occurred()) SWIG_fail;
30141 }
30142 {
30143 wxCursor * resultptr;
30144 resultptr = new wxCursor((wxCursor &)(result));
30145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30146 }
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30154 PyObject *resultobj;
30155 wxWindow *arg1 = (wxWindow *) 0 ;
30156 wxFont *arg2 = 0 ;
30157 bool result;
30158 PyObject * obj0 = 0 ;
30159 PyObject * obj1 = 0 ;
30160 char *kwnames[] = {
30161 (char *) "self",(char *) "font", NULL
30162 };
30163
30164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30166 if (SWIG_arg_fail(1)) SWIG_fail;
30167 {
30168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30169 if (SWIG_arg_fail(2)) SWIG_fail;
30170 if (arg2 == NULL) {
30171 SWIG_null_ref("wxFont");
30172 }
30173 if (SWIG_arg_fail(2)) SWIG_fail;
30174 }
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30178
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30184 }
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxWindow *arg1 = (wxWindow *) 0 ;
30194 wxFont *arg2 = 0 ;
30195 PyObject * obj0 = 0 ;
30196 PyObject * obj1 = 0 ;
30197 char *kwnames[] = {
30198 (char *) "self",(char *) "font", NULL
30199 };
30200
30201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30203 if (SWIG_arg_fail(1)) SWIG_fail;
30204 {
30205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(2)) SWIG_fail;
30207 if (arg2 == NULL) {
30208 SWIG_null_ref("wxFont");
30209 }
30210 if (SWIG_arg_fail(2)) SWIG_fail;
30211 }
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 (arg1)->SetOwnFont((wxFont const &)*arg2);
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 Py_INCREF(Py_None); resultobj = Py_None;
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30227 PyObject *resultobj;
30228 wxWindow *arg1 = (wxWindow *) 0 ;
30229 wxFont result;
30230 PyObject * obj0 = 0 ;
30231 char *kwnames[] = {
30232 (char *) "self", NULL
30233 };
30234
30235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30237 if (SWIG_arg_fail(1)) SWIG_fail;
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 result = (arg1)->GetFont();
30241
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 {
30246 wxFont * resultptr;
30247 resultptr = new wxFont((wxFont &)(result));
30248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30249 }
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30257 PyObject *resultobj;
30258 wxWindow *arg1 = (wxWindow *) 0 ;
30259 wxCaret *arg2 = (wxCaret *) 0 ;
30260 PyObject * obj0 = 0 ;
30261 PyObject * obj1 = 0 ;
30262 char *kwnames[] = {
30263 (char *) "self",(char *) "caret", NULL
30264 };
30265
30266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30268 if (SWIG_arg_fail(1)) SWIG_fail;
30269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(2)) SWIG_fail;
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 (arg1)->SetCaret(arg2);
30274
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 Py_INCREF(Py_None); resultobj = Py_None;
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj;
30287 wxWindow *arg1 = (wxWindow *) 0 ;
30288 wxCaret *result;
30289 PyObject * obj0 = 0 ;
30290 char *kwnames[] = {
30291 (char *) "self", NULL
30292 };
30293
30294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30300
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30312 PyObject *resultobj;
30313 wxWindow *arg1 = (wxWindow *) 0 ;
30314 int result;
30315 PyObject * obj0 = 0 ;
30316 char *kwnames[] = {
30317 (char *) "self", NULL
30318 };
30319
30320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30322 if (SWIG_arg_fail(1)) SWIG_fail;
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30326
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 {
30331 resultobj = SWIG_From_int((int)(result));
30332 }
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj;
30341 wxWindow *arg1 = (wxWindow *) 0 ;
30342 int result;
30343 PyObject * obj0 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self", NULL
30346 };
30347
30348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30350 if (SWIG_arg_fail(1)) SWIG_fail;
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 {
30359 resultobj = SWIG_From_int((int)(result));
30360 }
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30368 PyObject *resultobj;
30369 wxWindow *arg1 = (wxWindow *) 0 ;
30370 wxString *arg2 = 0 ;
30371 int *arg3 = (int *) 0 ;
30372 int *arg4 = (int *) 0 ;
30373 bool temp2 = false ;
30374 int temp3 ;
30375 int res3 = 0 ;
30376 int temp4 ;
30377 int res4 = 0 ;
30378 PyObject * obj0 = 0 ;
30379 PyObject * obj1 = 0 ;
30380 char *kwnames[] = {
30381 (char *) "self",(char *) "string", NULL
30382 };
30383
30384 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30385 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30388 if (SWIG_arg_fail(1)) SWIG_fail;
30389 {
30390 arg2 = wxString_in_helper(obj1);
30391 if (arg2 == NULL) SWIG_fail;
30392 temp2 = true;
30393 }
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 Py_INCREF(Py_None); resultobj = Py_None;
30402 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30403 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30404 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30405 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30406 {
30407 if (temp2)
30408 delete arg2;
30409 }
30410 return resultobj;
30411 fail:
30412 {
30413 if (temp2)
30414 delete arg2;
30415 }
30416 return NULL;
30417 }
30418
30419
30420 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj;
30422 wxWindow *arg1 = (wxWindow *) 0 ;
30423 wxString *arg2 = 0 ;
30424 int *arg3 = (int *) 0 ;
30425 int *arg4 = (int *) 0 ;
30426 int *arg5 = (int *) 0 ;
30427 int *arg6 = (int *) 0 ;
30428 wxFont *arg7 = (wxFont *) NULL ;
30429 bool temp2 = false ;
30430 int temp3 ;
30431 int res3 = 0 ;
30432 int temp4 ;
30433 int res4 = 0 ;
30434 int temp5 ;
30435 int res5 = 0 ;
30436 int temp6 ;
30437 int res6 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 PyObject * obj2 = 0 ;
30441 char *kwnames[] = {
30442 (char *) "self",(char *) "string",(char *) "font", NULL
30443 };
30444
30445 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30446 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30447 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30448 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 arg2 = wxString_in_helper(obj1);
30454 if (arg2 == NULL) SWIG_fail;
30455 temp2 = true;
30456 }
30457 if (obj2) {
30458 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30459 if (SWIG_arg_fail(7)) SWIG_fail;
30460 }
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30464
30465 wxPyEndAllowThreads(__tstate);
30466 if (PyErr_Occurred()) SWIG_fail;
30467 }
30468 Py_INCREF(Py_None); resultobj = Py_None;
30469 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30470 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30471 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30472 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30473 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30474 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30475 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30476 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30477 {
30478 if (temp2)
30479 delete arg2;
30480 }
30481 return resultobj;
30482 fail:
30483 {
30484 if (temp2)
30485 delete arg2;
30486 }
30487 return NULL;
30488 }
30489
30490
30491 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30492 PyObject *resultobj;
30493 wxWindow *arg1 = (wxWindow *) 0 ;
30494 int *arg2 = (int *) 0 ;
30495 int *arg3 = (int *) 0 ;
30496 int temp2 ;
30497 int res2 = 0 ;
30498 int temp3 ;
30499 int res3 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 PyObject * obj2 = 0 ;
30503 char *kwnames[] = {
30504 (char *) "self",(char *) "x",(char *) "y", NULL
30505 };
30506
30507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30509 if (SWIG_arg_fail(1)) SWIG_fail;
30510 {
30511 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30512 temp2 = SWIG_As_int(obj1);
30513 if (SWIG_arg_fail(2)) SWIG_fail;
30514 arg2 = &temp2;
30515 res2 = SWIG_NEWOBJ;
30516 }
30517 }
30518 {
30519 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30520 temp3 = SWIG_As_int(obj2);
30521 if (SWIG_arg_fail(3)) SWIG_fail;
30522 arg3 = &temp3;
30523 res3 = SWIG_NEWOBJ;
30524 }
30525 }
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30529
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 Py_INCREF(Py_None); resultobj = Py_None;
30534 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30535 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30536 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30537 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 int *arg2 = (int *) 0 ;
30548 int *arg3 = (int *) 0 ;
30549 int temp2 ;
30550 int res2 = 0 ;
30551 int temp3 ;
30552 int res3 = 0 ;
30553 PyObject * obj0 = 0 ;
30554 PyObject * obj1 = 0 ;
30555 PyObject * obj2 = 0 ;
30556 char *kwnames[] = {
30557 (char *) "self",(char *) "x",(char *) "y", NULL
30558 };
30559
30560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30562 if (SWIG_arg_fail(1)) SWIG_fail;
30563 {
30564 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30565 temp2 = SWIG_As_int(obj1);
30566 if (SWIG_arg_fail(2)) SWIG_fail;
30567 arg2 = &temp2;
30568 res2 = SWIG_NEWOBJ;
30569 }
30570 }
30571 {
30572 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30573 temp3 = SWIG_As_int(obj2);
30574 if (SWIG_arg_fail(3)) SWIG_fail;
30575 arg3 = &temp3;
30576 res3 = SWIG_NEWOBJ;
30577 }
30578 }
30579 {
30580 PyThreadState* __tstate = wxPyBeginAllowThreads();
30581 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30582
30583 wxPyEndAllowThreads(__tstate);
30584 if (PyErr_Occurred()) SWIG_fail;
30585 }
30586 Py_INCREF(Py_None); resultobj = Py_None;
30587 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30588 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30589 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30590 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30591 return resultobj;
30592 fail:
30593 return NULL;
30594 }
30595
30596
30597 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30598 PyObject *resultobj;
30599 wxWindow *arg1 = (wxWindow *) 0 ;
30600 wxPoint *arg2 = 0 ;
30601 wxPoint result;
30602 wxPoint temp2 ;
30603 PyObject * obj0 = 0 ;
30604 PyObject * obj1 = 0 ;
30605 char *kwnames[] = {
30606 (char *) "self",(char *) "pt", NULL
30607 };
30608
30609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30611 if (SWIG_arg_fail(1)) SWIG_fail;
30612 {
30613 arg2 = &temp2;
30614 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30615 }
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30619
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 {
30624 wxPoint * resultptr;
30625 resultptr = new wxPoint((wxPoint &)(result));
30626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30627 }
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj;
30636 wxWindow *arg1 = (wxWindow *) 0 ;
30637 wxPoint *arg2 = 0 ;
30638 wxPoint result;
30639 wxPoint temp2 ;
30640 PyObject * obj0 = 0 ;
30641 PyObject * obj1 = 0 ;
30642 char *kwnames[] = {
30643 (char *) "self",(char *) "pt", NULL
30644 };
30645
30646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30648 if (SWIG_arg_fail(1)) SWIG_fail;
30649 {
30650 arg2 = &temp2;
30651 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30652 }
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30656
30657 wxPyEndAllowThreads(__tstate);
30658 if (PyErr_Occurred()) SWIG_fail;
30659 }
30660 {
30661 wxPoint * resultptr;
30662 resultptr = new wxPoint((wxPoint &)(result));
30663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30664 }
30665 return resultobj;
30666 fail:
30667 return NULL;
30668 }
30669
30670
30671 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30672 PyObject *resultobj;
30673 wxWindow *arg1 = (wxWindow *) 0 ;
30674 int arg2 ;
30675 int arg3 ;
30676 wxHitTest result;
30677 PyObject * obj0 = 0 ;
30678 PyObject * obj1 = 0 ;
30679 PyObject * obj2 = 0 ;
30680 char *kwnames[] = {
30681 (char *) "self",(char *) "x",(char *) "y", NULL
30682 };
30683
30684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30686 if (SWIG_arg_fail(1)) SWIG_fail;
30687 {
30688 arg2 = (int)(SWIG_As_int(obj1));
30689 if (SWIG_arg_fail(2)) SWIG_fail;
30690 }
30691 {
30692 arg3 = (int)(SWIG_As_int(obj2));
30693 if (SWIG_arg_fail(3)) SWIG_fail;
30694 }
30695 {
30696 PyThreadState* __tstate = wxPyBeginAllowThreads();
30697 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30698
30699 wxPyEndAllowThreads(__tstate);
30700 if (PyErr_Occurred()) SWIG_fail;
30701 }
30702 resultobj = SWIG_From_int((result));
30703 return resultobj;
30704 fail:
30705 return NULL;
30706 }
30707
30708
30709 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30710 PyObject *resultobj;
30711 wxWindow *arg1 = (wxWindow *) 0 ;
30712 wxPoint *arg2 = 0 ;
30713 wxHitTest result;
30714 wxPoint temp2 ;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717 char *kwnames[] = {
30718 (char *) "self",(char *) "pt", NULL
30719 };
30720
30721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 arg2 = &temp2;
30726 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30727 }
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30731
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 resultobj = SWIG_From_int((result));
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30743 PyObject *resultobj;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 long arg2 ;
30746 wxBorder result;
30747 PyObject * obj0 = 0 ;
30748 PyObject * obj1 = 0 ;
30749
30750 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30752 if (SWIG_arg_fail(1)) SWIG_fail;
30753 {
30754 arg2 = (long)(SWIG_As_long(obj1));
30755 if (SWIG_arg_fail(2)) SWIG_fail;
30756 }
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_From_int((result));
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30772 PyObject *resultobj;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 wxBorder result;
30775 PyObject * obj0 = 0 ;
30776
30777 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30779 if (SWIG_arg_fail(1)) SWIG_fail;
30780 {
30781 PyThreadState* __tstate = wxPyBeginAllowThreads();
30782 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30783
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 resultobj = SWIG_From_int((result));
30788 return resultobj;
30789 fail:
30790 return NULL;
30791 }
30792
30793
30794 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30795 int argc;
30796 PyObject *argv[3];
30797 int ii;
30798
30799 argc = PyObject_Length(args);
30800 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30801 argv[ii] = PyTuple_GetItem(args,ii);
30802 }
30803 if (argc == 1) {
30804 int _v;
30805 {
30806 void *ptr;
30807 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30808 _v = 0;
30809 PyErr_Clear();
30810 } else {
30811 _v = 1;
30812 }
30813 }
30814 if (_v) {
30815 return _wrap_Window_GetBorder__SWIG_1(self,args);
30816 }
30817 }
30818 if (argc == 2) {
30819 int _v;
30820 {
30821 void *ptr;
30822 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30823 _v = 0;
30824 PyErr_Clear();
30825 } else {
30826 _v = 1;
30827 }
30828 }
30829 if (_v) {
30830 _v = SWIG_Check_long(argv[1]);
30831 if (_v) {
30832 return _wrap_Window_GetBorder__SWIG_0(self,args);
30833 }
30834 }
30835 }
30836
30837 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30838 return NULL;
30839 }
30840
30841
30842 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30843 PyObject *resultobj;
30844 wxWindow *arg1 = (wxWindow *) 0 ;
30845 long arg2 = (long) wxUPDATE_UI_NONE ;
30846 PyObject * obj0 = 0 ;
30847 PyObject * obj1 = 0 ;
30848 char *kwnames[] = {
30849 (char *) "self",(char *) "flags", NULL
30850 };
30851
30852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30854 if (SWIG_arg_fail(1)) SWIG_fail;
30855 if (obj1) {
30856 {
30857 arg2 = (long)(SWIG_As_long(obj1));
30858 if (SWIG_arg_fail(2)) SWIG_fail;
30859 }
30860 }
30861 {
30862 PyThreadState* __tstate = wxPyBeginAllowThreads();
30863 (arg1)->UpdateWindowUI(arg2);
30864
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 Py_INCREF(Py_None); resultobj = Py_None;
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj;
30877 wxWindow *arg1 = (wxWindow *) 0 ;
30878 wxMenu *arg2 = (wxMenu *) 0 ;
30879 int arg3 = (int) -1 ;
30880 int arg4 = (int) -1 ;
30881 bool result;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 PyObject * obj2 = 0 ;
30885 PyObject * obj3 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30894 if (SWIG_arg_fail(2)) SWIG_fail;
30895 if (obj2) {
30896 {
30897 arg3 = (int)(SWIG_As_int(obj2));
30898 if (SWIG_arg_fail(3)) SWIG_fail;
30899 }
30900 }
30901 if (obj3) {
30902 {
30903 arg4 = (int)(SWIG_As_int(obj3));
30904 if (SWIG_arg_fail(4)) SWIG_fail;
30905 }
30906 }
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 {
30915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30916 }
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30924 PyObject *resultobj;
30925 wxWindow *arg1 = (wxWindow *) 0 ;
30926 wxMenu *arg2 = (wxMenu *) 0 ;
30927 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30928 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30929 bool result;
30930 wxPoint temp3 ;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 PyObject * obj2 = 0 ;
30934 char *kwnames[] = {
30935 (char *) "self",(char *) "menu",(char *) "pos", NULL
30936 };
30937
30938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30940 if (SWIG_arg_fail(1)) SWIG_fail;
30941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30942 if (SWIG_arg_fail(2)) SWIG_fail;
30943 if (obj2) {
30944 {
30945 arg3 = &temp3;
30946 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30947 }
30948 }
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30952
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 {
30957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30958 }
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 long result;
30969 PyObject * obj0 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "self", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30976 if (SWIG_arg_fail(1)) SWIG_fail;
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 result = (long)wxWindow_GetHandle(arg1);
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 {
30985 resultobj = SWIG_From_long((long)(result));
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 long arg2 ;
30997 PyObject * obj0 = 0 ;
30998 PyObject * obj1 = 0 ;
30999 char *kwnames[] = {
31000 (char *) "self",(char *) "handle", NULL
31001 };
31002
31003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31005 if (SWIG_arg_fail(1)) SWIG_fail;
31006 {
31007 arg2 = (long)(SWIG_As_long(obj1));
31008 if (SWIG_arg_fail(2)) SWIG_fail;
31009 }
31010 {
31011 PyThreadState* __tstate = wxPyBeginAllowThreads();
31012 wxWindow_AssociateHandle(arg1,arg2);
31013
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 Py_INCREF(Py_None); resultobj = Py_None;
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxWindow *arg1 = (wxWindow *) 0 ;
31027 PyObject * obj0 = 0 ;
31028 char *kwnames[] = {
31029 (char *) "self", NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31034 if (SWIG_arg_fail(1)) SWIG_fail;
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 (arg1)->DissociateHandle();
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 Py_INCREF(Py_None); resultobj = Py_None;
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj;
31051 wxWindow *arg1 = (wxWindow *) 0 ;
31052 int arg2 ;
31053 bool result;
31054 PyObject * obj0 = 0 ;
31055 PyObject * obj1 = 0 ;
31056 char *kwnames[] = {
31057 (char *) "self",(char *) "orient", NULL
31058 };
31059
31060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31062 if (SWIG_arg_fail(1)) SWIG_fail;
31063 {
31064 arg2 = (int)(SWIG_As_int(obj1));
31065 if (SWIG_arg_fail(2)) SWIG_fail;
31066 }
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31070
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 {
31075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31076 }
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj;
31085 wxWindow *arg1 = (wxWindow *) 0 ;
31086 int arg2 ;
31087 int arg3 ;
31088 int arg4 ;
31089 int arg5 ;
31090 bool arg6 = (bool) true ;
31091 PyObject * obj0 = 0 ;
31092 PyObject * obj1 = 0 ;
31093 PyObject * obj2 = 0 ;
31094 PyObject * obj3 = 0 ;
31095 PyObject * obj4 = 0 ;
31096 PyObject * obj5 = 0 ;
31097 char *kwnames[] = {
31098 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31099 };
31100
31101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31103 if (SWIG_arg_fail(1)) SWIG_fail;
31104 {
31105 arg2 = (int)(SWIG_As_int(obj1));
31106 if (SWIG_arg_fail(2)) SWIG_fail;
31107 }
31108 {
31109 arg3 = (int)(SWIG_As_int(obj2));
31110 if (SWIG_arg_fail(3)) SWIG_fail;
31111 }
31112 {
31113 arg4 = (int)(SWIG_As_int(obj3));
31114 if (SWIG_arg_fail(4)) SWIG_fail;
31115 }
31116 {
31117 arg5 = (int)(SWIG_As_int(obj4));
31118 if (SWIG_arg_fail(5)) SWIG_fail;
31119 }
31120 if (obj5) {
31121 {
31122 arg6 = (bool)(SWIG_As_bool(obj5));
31123 if (SWIG_arg_fail(6)) SWIG_fail;
31124 }
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31129
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 Py_INCREF(Py_None); resultobj = Py_None;
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 int arg2 ;
31144 int arg3 ;
31145 bool arg4 = (bool) true ;
31146 PyObject * obj0 = 0 ;
31147 PyObject * obj1 = 0 ;
31148 PyObject * obj2 = 0 ;
31149 PyObject * obj3 = 0 ;
31150 char *kwnames[] = {
31151 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31152 };
31153
31154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31156 if (SWIG_arg_fail(1)) SWIG_fail;
31157 {
31158 arg2 = (int)(SWIG_As_int(obj1));
31159 if (SWIG_arg_fail(2)) SWIG_fail;
31160 }
31161 {
31162 arg3 = (int)(SWIG_As_int(obj2));
31163 if (SWIG_arg_fail(3)) SWIG_fail;
31164 }
31165 if (obj3) {
31166 {
31167 arg4 = (bool)(SWIG_As_bool(obj3));
31168 if (SWIG_arg_fail(4)) SWIG_fail;
31169 }
31170 }
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 (arg1)->SetScrollPos(arg2,arg3,arg4);
31174
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 Py_INCREF(Py_None); resultobj = Py_None;
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31186 PyObject *resultobj;
31187 wxWindow *arg1 = (wxWindow *) 0 ;
31188 int arg2 ;
31189 int result;
31190 PyObject * obj0 = 0 ;
31191 PyObject * obj1 = 0 ;
31192 char *kwnames[] = {
31193 (char *) "self",(char *) "orientation", NULL
31194 };
31195
31196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31198 if (SWIG_arg_fail(1)) SWIG_fail;
31199 {
31200 arg2 = (int)(SWIG_As_int(obj1));
31201 if (SWIG_arg_fail(2)) SWIG_fail;
31202 }
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31206
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 {
31211 resultobj = SWIG_From_int((int)(result));
31212 }
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 int arg2 ;
31223 int result;
31224 PyObject * obj0 = 0 ;
31225 PyObject * obj1 = 0 ;
31226 char *kwnames[] = {
31227 (char *) "self",(char *) "orientation", NULL
31228 };
31229
31230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31232 if (SWIG_arg_fail(1)) SWIG_fail;
31233 {
31234 arg2 = (int)(SWIG_As_int(obj1));
31235 if (SWIG_arg_fail(2)) SWIG_fail;
31236 }
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31240
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 {
31245 resultobj = SWIG_From_int((int)(result));
31246 }
31247 return resultobj;
31248 fail:
31249 return NULL;
31250 }
31251
31252
31253 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31254 PyObject *resultobj;
31255 wxWindow *arg1 = (wxWindow *) 0 ;
31256 int arg2 ;
31257 int result;
31258 PyObject * obj0 = 0 ;
31259 PyObject * obj1 = 0 ;
31260 char *kwnames[] = {
31261 (char *) "self",(char *) "orientation", NULL
31262 };
31263
31264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31266 if (SWIG_arg_fail(1)) SWIG_fail;
31267 {
31268 arg2 = (int)(SWIG_As_int(obj1));
31269 if (SWIG_arg_fail(2)) SWIG_fail;
31270 }
31271 {
31272 PyThreadState* __tstate = wxPyBeginAllowThreads();
31273 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31274
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 {
31279 resultobj = SWIG_From_int((int)(result));
31280 }
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj;
31289 wxWindow *arg1 = (wxWindow *) 0 ;
31290 int arg2 ;
31291 int arg3 ;
31292 wxRect *arg4 = (wxRect *) NULL ;
31293 PyObject * obj0 = 0 ;
31294 PyObject * obj1 = 0 ;
31295 PyObject * obj2 = 0 ;
31296 PyObject * obj3 = 0 ;
31297 char *kwnames[] = {
31298 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31299 };
31300
31301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31303 if (SWIG_arg_fail(1)) SWIG_fail;
31304 {
31305 arg2 = (int)(SWIG_As_int(obj1));
31306 if (SWIG_arg_fail(2)) SWIG_fail;
31307 }
31308 {
31309 arg3 = (int)(SWIG_As_int(obj2));
31310 if (SWIG_arg_fail(3)) SWIG_fail;
31311 }
31312 if (obj3) {
31313 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31314 if (SWIG_arg_fail(4)) SWIG_fail;
31315 }
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 Py_INCREF(Py_None); resultobj = Py_None;
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj;
31332 wxWindow *arg1 = (wxWindow *) 0 ;
31333 int arg2 ;
31334 bool result;
31335 PyObject * obj0 = 0 ;
31336 PyObject * obj1 = 0 ;
31337 char *kwnames[] = {
31338 (char *) "self",(char *) "lines", NULL
31339 };
31340
31341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31343 if (SWIG_arg_fail(1)) SWIG_fail;
31344 {
31345 arg2 = (int)(SWIG_As_int(obj1));
31346 if (SWIG_arg_fail(2)) SWIG_fail;
31347 }
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = (bool)(arg1)->ScrollLines(arg2);
31351
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 {
31356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31357 }
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj;
31366 wxWindow *arg1 = (wxWindow *) 0 ;
31367 int arg2 ;
31368 bool result;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self",(char *) "pages", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 arg2 = (int)(SWIG_As_int(obj1));
31380 if (SWIG_arg_fail(2)) SWIG_fail;
31381 }
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (bool)(arg1)->ScrollPages(arg2);
31385
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 bool result;
31402 PyObject * obj0 = 0 ;
31403 char *kwnames[] = {
31404 (char *) "self", NULL
31405 };
31406
31407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31409 if (SWIG_arg_fail(1)) SWIG_fail;
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 result = (bool)(arg1)->LineUp();
31413
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 {
31418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 bool result;
31430 PyObject * obj0 = 0 ;
31431 char *kwnames[] = {
31432 (char *) "self", NULL
31433 };
31434
31435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31437 if (SWIG_arg_fail(1)) SWIG_fail;
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = (bool)(arg1)->LineDown();
31441
31442 wxPyEndAllowThreads(__tstate);
31443 if (PyErr_Occurred()) SWIG_fail;
31444 }
31445 {
31446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31447 }
31448 return resultobj;
31449 fail:
31450 return NULL;
31451 }
31452
31453
31454 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31455 PyObject *resultobj;
31456 wxWindow *arg1 = (wxWindow *) 0 ;
31457 bool result;
31458 PyObject * obj0 = 0 ;
31459 char *kwnames[] = {
31460 (char *) "self", NULL
31461 };
31462
31463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31465 if (SWIG_arg_fail(1)) SWIG_fail;
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 result = (bool)(arg1)->PageUp();
31469
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 {
31474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31475 }
31476 return resultobj;
31477 fail:
31478 return NULL;
31479 }
31480
31481
31482 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31483 PyObject *resultobj;
31484 wxWindow *arg1 = (wxWindow *) 0 ;
31485 bool result;
31486 PyObject * obj0 = 0 ;
31487 char *kwnames[] = {
31488 (char *) "self", NULL
31489 };
31490
31491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31493 if (SWIG_arg_fail(1)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = (bool)(arg1)->PageDown();
31497
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 {
31502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31503 }
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31511 PyObject *resultobj;
31512 wxWindow *arg1 = (wxWindow *) 0 ;
31513 wxString *arg2 = 0 ;
31514 bool temp2 = false ;
31515 PyObject * obj0 = 0 ;
31516 PyObject * obj1 = 0 ;
31517 char *kwnames[] = {
31518 (char *) "self",(char *) "text", NULL
31519 };
31520
31521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31523 if (SWIG_arg_fail(1)) SWIG_fail;
31524 {
31525 arg2 = wxString_in_helper(obj1);
31526 if (arg2 == NULL) SWIG_fail;
31527 temp2 = true;
31528 }
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 (arg1)->SetHelpText((wxString const &)*arg2);
31532
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 Py_INCREF(Py_None); resultobj = Py_None;
31537 {
31538 if (temp2)
31539 delete arg2;
31540 }
31541 return resultobj;
31542 fail:
31543 {
31544 if (temp2)
31545 delete arg2;
31546 }
31547 return NULL;
31548 }
31549
31550
31551 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31552 PyObject *resultobj;
31553 wxWindow *arg1 = (wxWindow *) 0 ;
31554 wxString *arg2 = 0 ;
31555 bool temp2 = false ;
31556 PyObject * obj0 = 0 ;
31557 PyObject * obj1 = 0 ;
31558 char *kwnames[] = {
31559 (char *) "self",(char *) "text", NULL
31560 };
31561
31562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31564 if (SWIG_arg_fail(1)) SWIG_fail;
31565 {
31566 arg2 = wxString_in_helper(obj1);
31567 if (arg2 == NULL) SWIG_fail;
31568 temp2 = true;
31569 }
31570 {
31571 PyThreadState* __tstate = wxPyBeginAllowThreads();
31572 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31573
31574 wxPyEndAllowThreads(__tstate);
31575 if (PyErr_Occurred()) SWIG_fail;
31576 }
31577 Py_INCREF(Py_None); resultobj = Py_None;
31578 {
31579 if (temp2)
31580 delete arg2;
31581 }
31582 return resultobj;
31583 fail:
31584 {
31585 if (temp2)
31586 delete arg2;
31587 }
31588 return NULL;
31589 }
31590
31591
31592 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 wxString result;
31596 PyObject * obj0 = 0 ;
31597 char *kwnames[] = {
31598 (char *) "self", NULL
31599 };
31600
31601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31603 if (SWIG_arg_fail(1)) SWIG_fail;
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 result = ((wxWindow const *)arg1)->GetHelpText();
31607
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 {
31612 #if wxUSE_UNICODE
31613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31614 #else
31615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31616 #endif
31617 }
31618 return resultobj;
31619 fail:
31620 return NULL;
31621 }
31622
31623
31624 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31625 PyObject *resultobj;
31626 wxWindow *arg1 = (wxWindow *) 0 ;
31627 wxString *arg2 = 0 ;
31628 bool temp2 = false ;
31629 PyObject * obj0 = 0 ;
31630 PyObject * obj1 = 0 ;
31631 char *kwnames[] = {
31632 (char *) "self",(char *) "tip", NULL
31633 };
31634
31635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31637 if (SWIG_arg_fail(1)) SWIG_fail;
31638 {
31639 arg2 = wxString_in_helper(obj1);
31640 if (arg2 == NULL) SWIG_fail;
31641 temp2 = true;
31642 }
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 (arg1)->SetToolTip((wxString const &)*arg2);
31646
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 Py_INCREF(Py_None); resultobj = Py_None;
31651 {
31652 if (temp2)
31653 delete arg2;
31654 }
31655 return resultobj;
31656 fail:
31657 {
31658 if (temp2)
31659 delete arg2;
31660 }
31661 return NULL;
31662 }
31663
31664
31665 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31666 PyObject *resultobj;
31667 wxWindow *arg1 = (wxWindow *) 0 ;
31668 wxToolTip *arg2 = (wxToolTip *) 0 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 char *kwnames[] = {
31672 (char *) "self",(char *) "tip", NULL
31673 };
31674
31675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31677 if (SWIG_arg_fail(1)) SWIG_fail;
31678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31679 if (SWIG_arg_fail(2)) SWIG_fail;
31680 {
31681 PyThreadState* __tstate = wxPyBeginAllowThreads();
31682 (arg1)->SetToolTip(arg2);
31683
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 Py_INCREF(Py_None); resultobj = Py_None;
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31695 PyObject *resultobj;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 wxToolTip *result;
31698 PyObject * obj0 = 0 ;
31699 char *kwnames[] = {
31700 (char *) "self", NULL
31701 };
31702
31703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31705 if (SWIG_arg_fail(1)) SWIG_fail;
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31709
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 {
31714 resultobj = wxPyMake_wxObject(result, 0);
31715 }
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31723 PyObject *resultobj;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31726 PyObject * obj0 = 0 ;
31727 PyObject * obj1 = 0 ;
31728 char *kwnames[] = {
31729 (char *) "self",(char *) "dropTarget", NULL
31730 };
31731
31732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31734 if (SWIG_arg_fail(1)) SWIG_fail;
31735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31736 if (SWIG_arg_fail(2)) SWIG_fail;
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 (arg1)->SetDropTarget(arg2);
31740
31741 wxPyEndAllowThreads(__tstate);
31742 if (PyErr_Occurred()) SWIG_fail;
31743 }
31744 Py_INCREF(Py_None); resultobj = Py_None;
31745 return resultobj;
31746 fail:
31747 return NULL;
31748 }
31749
31750
31751 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31752 PyObject *resultobj;
31753 wxWindow *arg1 = (wxWindow *) 0 ;
31754 wxPyDropTarget *result;
31755 PyObject * obj0 = 0 ;
31756 char *kwnames[] = {
31757 (char *) "self", NULL
31758 };
31759
31760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31762 if (SWIG_arg_fail(1)) SWIG_fail;
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31766
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31778 PyObject *resultobj;
31779 wxWindow *arg1 = (wxWindow *) 0 ;
31780 bool arg2 ;
31781 PyObject * obj0 = 0 ;
31782 PyObject * obj1 = 0 ;
31783 char *kwnames[] = {
31784 (char *) "self",(char *) "accept", NULL
31785 };
31786
31787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31789 if (SWIG_arg_fail(1)) SWIG_fail;
31790 {
31791 arg2 = (bool)(SWIG_As_bool(obj1));
31792 if (SWIG_arg_fail(2)) SWIG_fail;
31793 }
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 wxWindow_DragAcceptFiles(arg1,arg2);
31797
31798 wxPyEndAllowThreads(__tstate);
31799 if (PyErr_Occurred()) SWIG_fail;
31800 }
31801 Py_INCREF(Py_None); resultobj = Py_None;
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31809 PyObject *resultobj;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31812 PyObject * obj0 = 0 ;
31813 PyObject * obj1 = 0 ;
31814 char *kwnames[] = {
31815 (char *) "self",(char *) "constraints", NULL
31816 };
31817
31818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31820 if (SWIG_arg_fail(1)) SWIG_fail;
31821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31822 if (SWIG_arg_fail(2)) SWIG_fail;
31823 {
31824 PyThreadState* __tstate = wxPyBeginAllowThreads();
31825 (arg1)->SetConstraints(arg2);
31826
31827 wxPyEndAllowThreads(__tstate);
31828 if (PyErr_Occurred()) SWIG_fail;
31829 }
31830 Py_INCREF(Py_None); resultobj = Py_None;
31831 return resultobj;
31832 fail:
31833 return NULL;
31834 }
31835
31836
31837 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31838 PyObject *resultobj;
31839 wxWindow *arg1 = (wxWindow *) 0 ;
31840 wxLayoutConstraints *result;
31841 PyObject * obj0 = 0 ;
31842 char *kwnames[] = {
31843 (char *) "self", NULL
31844 };
31845
31846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31848 if (SWIG_arg_fail(1)) SWIG_fail;
31849 {
31850 PyThreadState* __tstate = wxPyBeginAllowThreads();
31851 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31852
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 bool arg2 ;
31867 PyObject * obj0 = 0 ;
31868 PyObject * obj1 = 0 ;
31869 char *kwnames[] = {
31870 (char *) "self",(char *) "autoLayout", NULL
31871 };
31872
31873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31875 if (SWIG_arg_fail(1)) SWIG_fail;
31876 {
31877 arg2 = (bool)(SWIG_As_bool(obj1));
31878 if (SWIG_arg_fail(2)) SWIG_fail;
31879 }
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 (arg1)->SetAutoLayout(arg2);
31883
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 Py_INCREF(Py_None); resultobj = Py_None;
31888 return resultobj;
31889 fail:
31890 return NULL;
31891 }
31892
31893
31894 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31895 PyObject *resultobj;
31896 wxWindow *arg1 = (wxWindow *) 0 ;
31897 bool result;
31898 PyObject * obj0 = 0 ;
31899 char *kwnames[] = {
31900 (char *) "self", NULL
31901 };
31902
31903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31905 if (SWIG_arg_fail(1)) SWIG_fail;
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31909
31910 wxPyEndAllowThreads(__tstate);
31911 if (PyErr_Occurred()) SWIG_fail;
31912 }
31913 {
31914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31915 }
31916 return resultobj;
31917 fail:
31918 return NULL;
31919 }
31920
31921
31922 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31923 PyObject *resultobj;
31924 wxWindow *arg1 = (wxWindow *) 0 ;
31925 bool result;
31926 PyObject * obj0 = 0 ;
31927 char *kwnames[] = {
31928 (char *) "self", NULL
31929 };
31930
31931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31933 if (SWIG_arg_fail(1)) SWIG_fail;
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (bool)(arg1)->Layout();
31937
31938 wxPyEndAllowThreads(__tstate);
31939 if (PyErr_Occurred()) SWIG_fail;
31940 }
31941 {
31942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31943 }
31944 return resultobj;
31945 fail:
31946 return NULL;
31947 }
31948
31949
31950 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31951 PyObject *resultobj;
31952 wxWindow *arg1 = (wxWindow *) 0 ;
31953 wxSizer *arg2 = (wxSizer *) 0 ;
31954 bool arg3 = (bool) true ;
31955 PyObject * obj0 = 0 ;
31956 PyObject * obj1 = 0 ;
31957 PyObject * obj2 = 0 ;
31958 char *kwnames[] = {
31959 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31960 };
31961
31962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31964 if (SWIG_arg_fail(1)) SWIG_fail;
31965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31966 if (SWIG_arg_fail(2)) SWIG_fail;
31967 if (obj2) {
31968 {
31969 arg3 = (bool)(SWIG_As_bool(obj2));
31970 if (SWIG_arg_fail(3)) SWIG_fail;
31971 }
31972 }
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 (arg1)->SetSizer(arg2,arg3);
31976
31977 wxPyEndAllowThreads(__tstate);
31978 if (PyErr_Occurred()) SWIG_fail;
31979 }
31980 Py_INCREF(Py_None); resultobj = Py_None;
31981 return resultobj;
31982 fail:
31983 return NULL;
31984 }
31985
31986
31987 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj;
31989 wxWindow *arg1 = (wxWindow *) 0 ;
31990 wxSizer *arg2 = (wxSizer *) 0 ;
31991 bool arg3 = (bool) true ;
31992 PyObject * obj0 = 0 ;
31993 PyObject * obj1 = 0 ;
31994 PyObject * obj2 = 0 ;
31995 char *kwnames[] = {
31996 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31997 };
31998
31999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32001 if (SWIG_arg_fail(1)) SWIG_fail;
32002 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32003 if (SWIG_arg_fail(2)) SWIG_fail;
32004 if (obj2) {
32005 {
32006 arg3 = (bool)(SWIG_As_bool(obj2));
32007 if (SWIG_arg_fail(3)) SWIG_fail;
32008 }
32009 }
32010 {
32011 PyThreadState* __tstate = wxPyBeginAllowThreads();
32012 (arg1)->SetSizerAndFit(arg2,arg3);
32013
32014 wxPyEndAllowThreads(__tstate);
32015 if (PyErr_Occurred()) SWIG_fail;
32016 }
32017 Py_INCREF(Py_None); resultobj = Py_None;
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32025 PyObject *resultobj;
32026 wxWindow *arg1 = (wxWindow *) 0 ;
32027 wxSizer *result;
32028 PyObject * obj0 = 0 ;
32029 char *kwnames[] = {
32030 (char *) "self", NULL
32031 };
32032
32033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32035 if (SWIG_arg_fail(1)) SWIG_fail;
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32039
32040 wxPyEndAllowThreads(__tstate);
32041 if (PyErr_Occurred()) SWIG_fail;
32042 }
32043 {
32044 resultobj = wxPyMake_wxObject(result, 0);
32045 }
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32053 PyObject *resultobj;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 wxSizer *arg2 = (wxSizer *) 0 ;
32056 PyObject * obj0 = 0 ;
32057 PyObject * obj1 = 0 ;
32058 char *kwnames[] = {
32059 (char *) "self",(char *) "sizer", NULL
32060 };
32061
32062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32064 if (SWIG_arg_fail(1)) SWIG_fail;
32065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32066 if (SWIG_arg_fail(2)) SWIG_fail;
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 (arg1)->SetContainingSizer(arg2);
32070
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 Py_INCREF(Py_None); resultobj = Py_None;
32075 return resultobj;
32076 fail:
32077 return NULL;
32078 }
32079
32080
32081 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32082 PyObject *resultobj;
32083 wxWindow *arg1 = (wxWindow *) 0 ;
32084 wxSizer *result;
32085 PyObject * obj0 = 0 ;
32086 char *kwnames[] = {
32087 (char *) "self", NULL
32088 };
32089
32090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32092 if (SWIG_arg_fail(1)) SWIG_fail;
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32096
32097 wxPyEndAllowThreads(__tstate);
32098 if (PyErr_Occurred()) SWIG_fail;
32099 }
32100 {
32101 resultobj = wxPyMake_wxObject(result, 0);
32102 }
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32110 PyObject *resultobj;
32111 wxWindow *arg1 = (wxWindow *) 0 ;
32112 PyObject * obj0 = 0 ;
32113 char *kwnames[] = {
32114 (char *) "self", NULL
32115 };
32116
32117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32119 if (SWIG_arg_fail(1)) SWIG_fail;
32120 {
32121 PyThreadState* __tstate = wxPyBeginAllowThreads();
32122 (arg1)->InheritAttributes();
32123
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 Py_INCREF(Py_None); resultobj = Py_None;
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32135 PyObject *resultobj;
32136 wxWindow *arg1 = (wxWindow *) 0 ;
32137 bool result;
32138 PyObject * obj0 = 0 ;
32139 char *kwnames[] = {
32140 (char *) "self", NULL
32141 };
32142
32143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32145 if (SWIG_arg_fail(1)) SWIG_fail;
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32149
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 {
32154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32155 }
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32163 PyObject *obj;
32164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32165 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32166 Py_INCREF(obj);
32167 return Py_BuildValue((char *)"");
32168 }
32169 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32170 PyObject *resultobj;
32171 long arg1 ;
32172 wxWindow *arg2 = (wxWindow *) NULL ;
32173 wxWindow *result;
32174 PyObject * obj0 = 0 ;
32175 PyObject * obj1 = 0 ;
32176 char *kwnames[] = {
32177 (char *) "id",(char *) "parent", NULL
32178 };
32179
32180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32181 {
32182 arg1 = (long)(SWIG_As_long(obj0));
32183 if (SWIG_arg_fail(1)) SWIG_fail;
32184 }
32185 if (obj1) {
32186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32187 if (SWIG_arg_fail(2)) SWIG_fail;
32188 }
32189 {
32190 if (!wxPyCheckForApp()) SWIG_fail;
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32193
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 {
32198 resultobj = wxPyMake_wxObject(result, 0);
32199 }
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32207 PyObject *resultobj;
32208 wxString *arg1 = 0 ;
32209 wxWindow *arg2 = (wxWindow *) NULL ;
32210 wxWindow *result;
32211 bool temp1 = false ;
32212 PyObject * obj0 = 0 ;
32213 PyObject * obj1 = 0 ;
32214 char *kwnames[] = {
32215 (char *) "name",(char *) "parent", NULL
32216 };
32217
32218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32219 {
32220 arg1 = wxString_in_helper(obj0);
32221 if (arg1 == NULL) SWIG_fail;
32222 temp1 = true;
32223 }
32224 if (obj1) {
32225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32226 if (SWIG_arg_fail(2)) SWIG_fail;
32227 }
32228 {
32229 if (!wxPyCheckForApp()) SWIG_fail;
32230 PyThreadState* __tstate = wxPyBeginAllowThreads();
32231 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32232
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 resultobj = wxPyMake_wxObject(result, 0);
32238 }
32239 {
32240 if (temp1)
32241 delete arg1;
32242 }
32243 return resultobj;
32244 fail:
32245 {
32246 if (temp1)
32247 delete arg1;
32248 }
32249 return NULL;
32250 }
32251
32252
32253 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32254 PyObject *resultobj;
32255 wxString *arg1 = 0 ;
32256 wxWindow *arg2 = (wxWindow *) NULL ;
32257 wxWindow *result;
32258 bool temp1 = false ;
32259 PyObject * obj0 = 0 ;
32260 PyObject * obj1 = 0 ;
32261 char *kwnames[] = {
32262 (char *) "label",(char *) "parent", NULL
32263 };
32264
32265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32266 {
32267 arg1 = wxString_in_helper(obj0);
32268 if (arg1 == NULL) SWIG_fail;
32269 temp1 = true;
32270 }
32271 if (obj1) {
32272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32273 if (SWIG_arg_fail(2)) SWIG_fail;
32274 }
32275 {
32276 if (!wxPyCheckForApp()) SWIG_fail;
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32279
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = wxPyMake_wxObject(result, 0);
32285 }
32286 {
32287 if (temp1)
32288 delete arg1;
32289 }
32290 return resultobj;
32291 fail:
32292 {
32293 if (temp1)
32294 delete arg1;
32295 }
32296 return NULL;
32297 }
32298
32299
32300 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj;
32302 wxWindow *arg1 = (wxWindow *) 0 ;
32303 unsigned long arg2 ;
32304 wxWindow *result;
32305 PyObject * obj0 = 0 ;
32306 PyObject * obj1 = 0 ;
32307 char *kwnames[] = {
32308 (char *) "parent",(char *) "_hWnd", NULL
32309 };
32310
32311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32313 if (SWIG_arg_fail(1)) SWIG_fail;
32314 {
32315 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32316 if (SWIG_arg_fail(2)) SWIG_fail;
32317 }
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32321
32322 wxPyEndAllowThreads(__tstate);
32323 if (PyErr_Occurred()) SWIG_fail;
32324 }
32325 {
32326 resultobj = wxPyMake_wxObject(result, 0);
32327 }
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32335 PyObject *resultobj;
32336 PyObject *result;
32337 char *kwnames[] = {
32338 NULL
32339 };
32340
32341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = (PyObject *)GetTopLevelWindows();
32345
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 resultobj = result;
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj;
32358 wxValidator *result;
32359 char *kwnames[] = {
32360 NULL
32361 };
32362
32363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (wxValidator *)new wxValidator();
32367
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32379 PyObject *resultobj;
32380 wxValidator *arg1 = (wxValidator *) 0 ;
32381 wxValidator *result;
32382 PyObject * obj0 = 0 ;
32383 char *kwnames[] = {
32384 (char *) "self", NULL
32385 };
32386
32387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32389 if (SWIG_arg_fail(1)) SWIG_fail;
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 result = (wxValidator *)(arg1)->Clone();
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 {
32398 resultobj = wxPyMake_wxObject(result, 0);
32399 }
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32407 PyObject *resultobj;
32408 wxValidator *arg1 = (wxValidator *) 0 ;
32409 wxWindow *arg2 = (wxWindow *) 0 ;
32410 bool result;
32411 PyObject * obj0 = 0 ;
32412 PyObject * obj1 = 0 ;
32413 char *kwnames[] = {
32414 (char *) "self",(char *) "parent", NULL
32415 };
32416
32417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32419 if (SWIG_arg_fail(1)) SWIG_fail;
32420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32421 if (SWIG_arg_fail(2)) SWIG_fail;
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 result = (bool)(arg1)->Validate(arg2);
32425
32426 wxPyEndAllowThreads(__tstate);
32427 if (PyErr_Occurred()) SWIG_fail;
32428 }
32429 {
32430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32431 }
32432 return resultobj;
32433 fail:
32434 return NULL;
32435 }
32436
32437
32438 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32439 PyObject *resultobj;
32440 wxValidator *arg1 = (wxValidator *) 0 ;
32441 bool result;
32442 PyObject * obj0 = 0 ;
32443 char *kwnames[] = {
32444 (char *) "self", NULL
32445 };
32446
32447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32449 if (SWIG_arg_fail(1)) SWIG_fail;
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 result = (bool)(arg1)->TransferToWindow();
32453
32454 wxPyEndAllowThreads(__tstate);
32455 if (PyErr_Occurred()) SWIG_fail;
32456 }
32457 {
32458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32459 }
32460 return resultobj;
32461 fail:
32462 return NULL;
32463 }
32464
32465
32466 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32467 PyObject *resultobj;
32468 wxValidator *arg1 = (wxValidator *) 0 ;
32469 bool result;
32470 PyObject * obj0 = 0 ;
32471 char *kwnames[] = {
32472 (char *) "self", NULL
32473 };
32474
32475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32477 if (SWIG_arg_fail(1)) SWIG_fail;
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (bool)(arg1)->TransferFromWindow();
32481
32482 wxPyEndAllowThreads(__tstate);
32483 if (PyErr_Occurred()) SWIG_fail;
32484 }
32485 {
32486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32487 }
32488 return resultobj;
32489 fail:
32490 return NULL;
32491 }
32492
32493
32494 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32495 PyObject *resultobj;
32496 wxValidator *arg1 = (wxValidator *) 0 ;
32497 wxWindow *result;
32498 PyObject * obj0 = 0 ;
32499 char *kwnames[] = {
32500 (char *) "self", NULL
32501 };
32502
32503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32505 if (SWIG_arg_fail(1)) SWIG_fail;
32506 {
32507 PyThreadState* __tstate = wxPyBeginAllowThreads();
32508 result = (wxWindow *)(arg1)->GetWindow();
32509
32510 wxPyEndAllowThreads(__tstate);
32511 if (PyErr_Occurred()) SWIG_fail;
32512 }
32513 {
32514 resultobj = wxPyMake_wxObject(result, 0);
32515 }
32516 return resultobj;
32517 fail:
32518 return NULL;
32519 }
32520
32521
32522 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32523 PyObject *resultobj;
32524 wxValidator *arg1 = (wxValidator *) 0 ;
32525 wxWindow *arg2 = (wxWindow *) 0 ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 char *kwnames[] = {
32529 (char *) "self",(char *) "window", NULL
32530 };
32531
32532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32534 if (SWIG_arg_fail(1)) SWIG_fail;
32535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32536 if (SWIG_arg_fail(2)) SWIG_fail;
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 (arg1)->SetWindow(arg2);
32540
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 Py_INCREF(Py_None); resultobj = Py_None;
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj;
32553 bool result;
32554 char *kwnames[] = {
32555 NULL
32556 };
32557
32558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 result = (bool)wxValidator::IsSilent();
32562
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 {
32567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32568 }
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32576 PyObject *resultobj;
32577 int arg1 = (int) true ;
32578 PyObject * obj0 = 0 ;
32579 char *kwnames[] = {
32580 (char *) "doIt", NULL
32581 };
32582
32583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32584 if (obj0) {
32585 {
32586 arg1 = (int)(SWIG_As_int(obj0));
32587 if (SWIG_arg_fail(1)) SWIG_fail;
32588 }
32589 }
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 wxValidator::SetBellOnError(arg1);
32593
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 Py_INCREF(Py_None); resultobj = Py_None;
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32605 PyObject *obj;
32606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32607 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32608 Py_INCREF(obj);
32609 return Py_BuildValue((char *)"");
32610 }
32611 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32612 PyObject *resultobj;
32613 wxPyValidator *result;
32614 char *kwnames[] = {
32615 NULL
32616 };
32617
32618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 result = (wxPyValidator *)new wxPyValidator();
32622
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32627 return resultobj;
32628 fail:
32629 return NULL;
32630 }
32631
32632
32633 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32634 PyObject *resultobj;
32635 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32636 PyObject *arg2 = (PyObject *) 0 ;
32637 PyObject *arg3 = (PyObject *) 0 ;
32638 int arg4 = (int) true ;
32639 PyObject * obj0 = 0 ;
32640 PyObject * obj1 = 0 ;
32641 PyObject * obj2 = 0 ;
32642 PyObject * obj3 = 0 ;
32643 char *kwnames[] = {
32644 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32645 };
32646
32647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32649 if (SWIG_arg_fail(1)) SWIG_fail;
32650 arg2 = obj1;
32651 arg3 = obj2;
32652 if (obj3) {
32653 {
32654 arg4 = (int)(SWIG_As_int(obj3));
32655 if (SWIG_arg_fail(4)) SWIG_fail;
32656 }
32657 }
32658 {
32659 PyThreadState* __tstate = wxPyBeginAllowThreads();
32660 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32661
32662 wxPyEndAllowThreads(__tstate);
32663 if (PyErr_Occurred()) SWIG_fail;
32664 }
32665 Py_INCREF(Py_None); resultobj = Py_None;
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32673 PyObject *obj;
32674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32675 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32676 Py_INCREF(obj);
32677 return Py_BuildValue((char *)"");
32678 }
32679 static int _wrap_DefaultValidator_set(PyObject *) {
32680 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32681 return 1;
32682 }
32683
32684
32685 static PyObject *_wrap_DefaultValidator_get(void) {
32686 PyObject *pyobj;
32687
32688 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32689 return pyobj;
32690 }
32691
32692
32693 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32694 PyObject *resultobj;
32695 wxString const &arg1_defvalue = wxPyEmptyString ;
32696 wxString *arg1 = (wxString *) &arg1_defvalue ;
32697 long arg2 = (long) 0 ;
32698 wxMenu *result;
32699 bool temp1 = false ;
32700 PyObject * obj0 = 0 ;
32701 PyObject * obj1 = 0 ;
32702 char *kwnames[] = {
32703 (char *) "title",(char *) "style", NULL
32704 };
32705
32706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32707 if (obj0) {
32708 {
32709 arg1 = wxString_in_helper(obj0);
32710 if (arg1 == NULL) SWIG_fail;
32711 temp1 = true;
32712 }
32713 }
32714 if (obj1) {
32715 {
32716 arg2 = (long)(SWIG_As_long(obj1));
32717 if (SWIG_arg_fail(2)) SWIG_fail;
32718 }
32719 }
32720 {
32721 if (!wxPyCheckForApp()) SWIG_fail;
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32724
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32729 {
32730 if (temp1)
32731 delete arg1;
32732 }
32733 return resultobj;
32734 fail:
32735 {
32736 if (temp1)
32737 delete arg1;
32738 }
32739 return NULL;
32740 }
32741
32742
32743 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj;
32745 wxMenu *arg1 = (wxMenu *) 0 ;
32746 int arg2 ;
32747 wxString *arg3 = 0 ;
32748 wxString const &arg4_defvalue = wxPyEmptyString ;
32749 wxString *arg4 = (wxString *) &arg4_defvalue ;
32750 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32751 wxMenuItem *result;
32752 bool temp3 = false ;
32753 bool temp4 = false ;
32754 PyObject * obj0 = 0 ;
32755 PyObject * obj1 = 0 ;
32756 PyObject * obj2 = 0 ;
32757 PyObject * obj3 = 0 ;
32758 PyObject * obj4 = 0 ;
32759 char *kwnames[] = {
32760 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32761 };
32762
32763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32765 if (SWIG_arg_fail(1)) SWIG_fail;
32766 {
32767 arg2 = (int)(SWIG_As_int(obj1));
32768 if (SWIG_arg_fail(2)) SWIG_fail;
32769 }
32770 {
32771 arg3 = wxString_in_helper(obj2);
32772 if (arg3 == NULL) SWIG_fail;
32773 temp3 = true;
32774 }
32775 if (obj3) {
32776 {
32777 arg4 = wxString_in_helper(obj3);
32778 if (arg4 == NULL) SWIG_fail;
32779 temp4 = true;
32780 }
32781 }
32782 if (obj4) {
32783 {
32784 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32785 if (SWIG_arg_fail(5)) SWIG_fail;
32786 }
32787 }
32788 {
32789 PyThreadState* __tstate = wxPyBeginAllowThreads();
32790 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32791
32792 wxPyEndAllowThreads(__tstate);
32793 if (PyErr_Occurred()) SWIG_fail;
32794 }
32795 {
32796 resultobj = wxPyMake_wxObject(result, 0);
32797 }
32798 {
32799 if (temp3)
32800 delete arg3;
32801 }
32802 {
32803 if (temp4)
32804 delete arg4;
32805 }
32806 return resultobj;
32807 fail:
32808 {
32809 if (temp3)
32810 delete arg3;
32811 }
32812 {
32813 if (temp4)
32814 delete arg4;
32815 }
32816 return NULL;
32817 }
32818
32819
32820 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32821 PyObject *resultobj;
32822 wxMenu *arg1 = (wxMenu *) 0 ;
32823 wxMenuItem *result;
32824 PyObject * obj0 = 0 ;
32825 char *kwnames[] = {
32826 (char *) "self", NULL
32827 };
32828
32829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32831 if (SWIG_arg_fail(1)) SWIG_fail;
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 result = (wxMenuItem *)(arg1)->AppendSeparator();
32835
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 {
32840 resultobj = wxPyMake_wxObject(result, 0);
32841 }
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32849 PyObject *resultobj;
32850 wxMenu *arg1 = (wxMenu *) 0 ;
32851 int arg2 ;
32852 wxString *arg3 = 0 ;
32853 wxString const &arg4_defvalue = wxPyEmptyString ;
32854 wxString *arg4 = (wxString *) &arg4_defvalue ;
32855 wxMenuItem *result;
32856 bool temp3 = false ;
32857 bool temp4 = false ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 PyObject * obj2 = 0 ;
32861 PyObject * obj3 = 0 ;
32862 char *kwnames[] = {
32863 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32864 };
32865
32866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32868 if (SWIG_arg_fail(1)) SWIG_fail;
32869 {
32870 arg2 = (int)(SWIG_As_int(obj1));
32871 if (SWIG_arg_fail(2)) SWIG_fail;
32872 }
32873 {
32874 arg3 = wxString_in_helper(obj2);
32875 if (arg3 == NULL) SWIG_fail;
32876 temp3 = true;
32877 }
32878 if (obj3) {
32879 {
32880 arg4 = wxString_in_helper(obj3);
32881 if (arg4 == NULL) SWIG_fail;
32882 temp4 = true;
32883 }
32884 }
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32888
32889 wxPyEndAllowThreads(__tstate);
32890 if (PyErr_Occurred()) SWIG_fail;
32891 }
32892 {
32893 resultobj = wxPyMake_wxObject(result, 0);
32894 }
32895 {
32896 if (temp3)
32897 delete arg3;
32898 }
32899 {
32900 if (temp4)
32901 delete arg4;
32902 }
32903 return resultobj;
32904 fail:
32905 {
32906 if (temp3)
32907 delete arg3;
32908 }
32909 {
32910 if (temp4)
32911 delete arg4;
32912 }
32913 return NULL;
32914 }
32915
32916
32917 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32918 PyObject *resultobj;
32919 wxMenu *arg1 = (wxMenu *) 0 ;
32920 int arg2 ;
32921 wxString *arg3 = 0 ;
32922 wxString const &arg4_defvalue = wxPyEmptyString ;
32923 wxString *arg4 = (wxString *) &arg4_defvalue ;
32924 wxMenuItem *result;
32925 bool temp3 = false ;
32926 bool temp4 = false ;
32927 PyObject * obj0 = 0 ;
32928 PyObject * obj1 = 0 ;
32929 PyObject * obj2 = 0 ;
32930 PyObject * obj3 = 0 ;
32931 char *kwnames[] = {
32932 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32933 };
32934
32935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32937 if (SWIG_arg_fail(1)) SWIG_fail;
32938 {
32939 arg2 = (int)(SWIG_As_int(obj1));
32940 if (SWIG_arg_fail(2)) SWIG_fail;
32941 }
32942 {
32943 arg3 = wxString_in_helper(obj2);
32944 if (arg3 == NULL) SWIG_fail;
32945 temp3 = true;
32946 }
32947 if (obj3) {
32948 {
32949 arg4 = wxString_in_helper(obj3);
32950 if (arg4 == NULL) SWIG_fail;
32951 temp4 = true;
32952 }
32953 }
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32957
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 {
32962 resultobj = wxPyMake_wxObject(result, 0);
32963 }
32964 {
32965 if (temp3)
32966 delete arg3;
32967 }
32968 {
32969 if (temp4)
32970 delete arg4;
32971 }
32972 return resultobj;
32973 fail:
32974 {
32975 if (temp3)
32976 delete arg3;
32977 }
32978 {
32979 if (temp4)
32980 delete arg4;
32981 }
32982 return NULL;
32983 }
32984
32985
32986 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32987 PyObject *resultobj;
32988 wxMenu *arg1 = (wxMenu *) 0 ;
32989 int arg2 ;
32990 wxString *arg3 = 0 ;
32991 wxMenu *arg4 = (wxMenu *) 0 ;
32992 wxString const &arg5_defvalue = wxPyEmptyString ;
32993 wxString *arg5 = (wxString *) &arg5_defvalue ;
32994 wxMenuItem *result;
32995 bool temp3 = false ;
32996 bool temp5 = false ;
32997 PyObject * obj0 = 0 ;
32998 PyObject * obj1 = 0 ;
32999 PyObject * obj2 = 0 ;
33000 PyObject * obj3 = 0 ;
33001 PyObject * obj4 = 0 ;
33002 char *kwnames[] = {
33003 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33004 };
33005
33006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33008 if (SWIG_arg_fail(1)) SWIG_fail;
33009 {
33010 arg2 = (int)(SWIG_As_int(obj1));
33011 if (SWIG_arg_fail(2)) SWIG_fail;
33012 }
33013 {
33014 arg3 = wxString_in_helper(obj2);
33015 if (arg3 == NULL) SWIG_fail;
33016 temp3 = true;
33017 }
33018 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33019 if (SWIG_arg_fail(4)) SWIG_fail;
33020 if (obj4) {
33021 {
33022 arg5 = wxString_in_helper(obj4);
33023 if (arg5 == NULL) SWIG_fail;
33024 temp5 = true;
33025 }
33026 }
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33030
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 {
33035 resultobj = wxPyMake_wxObject(result, 0);
33036 }
33037 {
33038 if (temp3)
33039 delete arg3;
33040 }
33041 {
33042 if (temp5)
33043 delete arg5;
33044 }
33045 return resultobj;
33046 fail:
33047 {
33048 if (temp3)
33049 delete arg3;
33050 }
33051 {
33052 if (temp5)
33053 delete arg5;
33054 }
33055 return NULL;
33056 }
33057
33058
33059 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj;
33061 wxMenu *arg1 = (wxMenu *) 0 ;
33062 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33063 wxMenuItem *result;
33064 PyObject * obj0 = 0 ;
33065 PyObject * obj1 = 0 ;
33066 char *kwnames[] = {
33067 (char *) "self",(char *) "item", NULL
33068 };
33069
33070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33072 if (SWIG_arg_fail(1)) SWIG_fail;
33073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33074 if (SWIG_arg_fail(2)) SWIG_fail;
33075 {
33076 PyThreadState* __tstate = wxPyBeginAllowThreads();
33077 result = (wxMenuItem *)(arg1)->Append(arg2);
33078
33079 wxPyEndAllowThreads(__tstate);
33080 if (PyErr_Occurred()) SWIG_fail;
33081 }
33082 {
33083 resultobj = wxPyMake_wxObject(result, 0);
33084 }
33085 return resultobj;
33086 fail:
33087 return NULL;
33088 }
33089
33090
33091 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33092 PyObject *resultobj;
33093 wxMenu *arg1 = (wxMenu *) 0 ;
33094 PyObject * obj0 = 0 ;
33095 char *kwnames[] = {
33096 (char *) "self", NULL
33097 };
33098
33099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33101 if (SWIG_arg_fail(1)) SWIG_fail;
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 (arg1)->Break();
33105
33106 wxPyEndAllowThreads(__tstate);
33107 if (PyErr_Occurred()) SWIG_fail;
33108 }
33109 Py_INCREF(Py_None); resultobj = Py_None;
33110 return resultobj;
33111 fail:
33112 return NULL;
33113 }
33114
33115
33116 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33117 PyObject *resultobj;
33118 wxMenu *arg1 = (wxMenu *) 0 ;
33119 size_t arg2 ;
33120 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33121 wxMenuItem *result;
33122 PyObject * obj0 = 0 ;
33123 PyObject * obj1 = 0 ;
33124 PyObject * obj2 = 0 ;
33125 char *kwnames[] = {
33126 (char *) "self",(char *) "pos",(char *) "item", NULL
33127 };
33128
33129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33131 if (SWIG_arg_fail(1)) SWIG_fail;
33132 {
33133 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33134 if (SWIG_arg_fail(2)) SWIG_fail;
33135 }
33136 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33137 if (SWIG_arg_fail(3)) SWIG_fail;
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33141
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 {
33146 resultobj = wxPyMake_wxObject(result, 0);
33147 }
33148 return resultobj;
33149 fail:
33150 return NULL;
33151 }
33152
33153
33154 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33155 PyObject *resultobj;
33156 wxMenu *arg1 = (wxMenu *) 0 ;
33157 size_t arg2 ;
33158 int arg3 ;
33159 wxString *arg4 = 0 ;
33160 wxString const &arg5_defvalue = wxPyEmptyString ;
33161 wxString *arg5 = (wxString *) &arg5_defvalue ;
33162 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33163 wxMenuItem *result;
33164 bool temp4 = false ;
33165 bool temp5 = false ;
33166 PyObject * obj0 = 0 ;
33167 PyObject * obj1 = 0 ;
33168 PyObject * obj2 = 0 ;
33169 PyObject * obj3 = 0 ;
33170 PyObject * obj4 = 0 ;
33171 PyObject * obj5 = 0 ;
33172 char *kwnames[] = {
33173 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33174 };
33175
33176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33178 if (SWIG_arg_fail(1)) SWIG_fail;
33179 {
33180 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33181 if (SWIG_arg_fail(2)) SWIG_fail;
33182 }
33183 {
33184 arg3 = (int)(SWIG_As_int(obj2));
33185 if (SWIG_arg_fail(3)) SWIG_fail;
33186 }
33187 {
33188 arg4 = wxString_in_helper(obj3);
33189 if (arg4 == NULL) SWIG_fail;
33190 temp4 = true;
33191 }
33192 if (obj4) {
33193 {
33194 arg5 = wxString_in_helper(obj4);
33195 if (arg5 == NULL) SWIG_fail;
33196 temp5 = true;
33197 }
33198 }
33199 if (obj5) {
33200 {
33201 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33202 if (SWIG_arg_fail(6)) SWIG_fail;
33203 }
33204 }
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = wxPyMake_wxObject(result, 0);
33214 }
33215 {
33216 if (temp4)
33217 delete arg4;
33218 }
33219 {
33220 if (temp5)
33221 delete arg5;
33222 }
33223 return resultobj;
33224 fail:
33225 {
33226 if (temp4)
33227 delete arg4;
33228 }
33229 {
33230 if (temp5)
33231 delete arg5;
33232 }
33233 return NULL;
33234 }
33235
33236
33237 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33238 PyObject *resultobj;
33239 wxMenu *arg1 = (wxMenu *) 0 ;
33240 size_t arg2 ;
33241 wxMenuItem *result;
33242 PyObject * obj0 = 0 ;
33243 PyObject * obj1 = 0 ;
33244 char *kwnames[] = {
33245 (char *) "self",(char *) "pos", NULL
33246 };
33247
33248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33250 if (SWIG_arg_fail(1)) SWIG_fail;
33251 {
33252 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33253 if (SWIG_arg_fail(2)) SWIG_fail;
33254 }
33255 {
33256 PyThreadState* __tstate = wxPyBeginAllowThreads();
33257 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33258
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 resultobj = wxPyMake_wxObject(result, 0);
33264 }
33265 return resultobj;
33266 fail:
33267 return NULL;
33268 }
33269
33270
33271 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33272 PyObject *resultobj;
33273 wxMenu *arg1 = (wxMenu *) 0 ;
33274 size_t arg2 ;
33275 int arg3 ;
33276 wxString *arg4 = 0 ;
33277 wxString const &arg5_defvalue = wxPyEmptyString ;
33278 wxString *arg5 = (wxString *) &arg5_defvalue ;
33279 wxMenuItem *result;
33280 bool temp4 = false ;
33281 bool temp5 = false ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 PyObject * obj2 = 0 ;
33285 PyObject * obj3 = 0 ;
33286 PyObject * obj4 = 0 ;
33287 char *kwnames[] = {
33288 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33289 };
33290
33291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33293 if (SWIG_arg_fail(1)) SWIG_fail;
33294 {
33295 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33296 if (SWIG_arg_fail(2)) SWIG_fail;
33297 }
33298 {
33299 arg3 = (int)(SWIG_As_int(obj2));
33300 if (SWIG_arg_fail(3)) SWIG_fail;
33301 }
33302 {
33303 arg4 = wxString_in_helper(obj3);
33304 if (arg4 == NULL) SWIG_fail;
33305 temp4 = true;
33306 }
33307 if (obj4) {
33308 {
33309 arg5 = wxString_in_helper(obj4);
33310 if (arg5 == NULL) SWIG_fail;
33311 temp5 = true;
33312 }
33313 }
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33317
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 {
33322 resultobj = wxPyMake_wxObject(result, 0);
33323 }
33324 {
33325 if (temp4)
33326 delete arg4;
33327 }
33328 {
33329 if (temp5)
33330 delete arg5;
33331 }
33332 return resultobj;
33333 fail:
33334 {
33335 if (temp4)
33336 delete arg4;
33337 }
33338 {
33339 if (temp5)
33340 delete arg5;
33341 }
33342 return NULL;
33343 }
33344
33345
33346 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33347 PyObject *resultobj;
33348 wxMenu *arg1 = (wxMenu *) 0 ;
33349 size_t arg2 ;
33350 int arg3 ;
33351 wxString *arg4 = 0 ;
33352 wxString const &arg5_defvalue = wxPyEmptyString ;
33353 wxString *arg5 = (wxString *) &arg5_defvalue ;
33354 wxMenuItem *result;
33355 bool temp4 = false ;
33356 bool temp5 = false ;
33357 PyObject * obj0 = 0 ;
33358 PyObject * obj1 = 0 ;
33359 PyObject * obj2 = 0 ;
33360 PyObject * obj3 = 0 ;
33361 PyObject * obj4 = 0 ;
33362 char *kwnames[] = {
33363 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33364 };
33365
33366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33368 if (SWIG_arg_fail(1)) SWIG_fail;
33369 {
33370 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33371 if (SWIG_arg_fail(2)) SWIG_fail;
33372 }
33373 {
33374 arg3 = (int)(SWIG_As_int(obj2));
33375 if (SWIG_arg_fail(3)) SWIG_fail;
33376 }
33377 {
33378 arg4 = wxString_in_helper(obj3);
33379 if (arg4 == NULL) SWIG_fail;
33380 temp4 = true;
33381 }
33382 if (obj4) {
33383 {
33384 arg5 = wxString_in_helper(obj4);
33385 if (arg5 == NULL) SWIG_fail;
33386 temp5 = true;
33387 }
33388 }
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33392
33393 wxPyEndAllowThreads(__tstate);
33394 if (PyErr_Occurred()) SWIG_fail;
33395 }
33396 {
33397 resultobj = wxPyMake_wxObject(result, 0);
33398 }
33399 {
33400 if (temp4)
33401 delete arg4;
33402 }
33403 {
33404 if (temp5)
33405 delete arg5;
33406 }
33407 return resultobj;
33408 fail:
33409 {
33410 if (temp4)
33411 delete arg4;
33412 }
33413 {
33414 if (temp5)
33415 delete arg5;
33416 }
33417 return NULL;
33418 }
33419
33420
33421 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33422 PyObject *resultobj;
33423 wxMenu *arg1 = (wxMenu *) 0 ;
33424 size_t arg2 ;
33425 int arg3 ;
33426 wxString *arg4 = 0 ;
33427 wxMenu *arg5 = (wxMenu *) 0 ;
33428 wxString const &arg6_defvalue = wxPyEmptyString ;
33429 wxString *arg6 = (wxString *) &arg6_defvalue ;
33430 wxMenuItem *result;
33431 bool temp4 = false ;
33432 bool temp6 = false ;
33433 PyObject * obj0 = 0 ;
33434 PyObject * obj1 = 0 ;
33435 PyObject * obj2 = 0 ;
33436 PyObject * obj3 = 0 ;
33437 PyObject * obj4 = 0 ;
33438 PyObject * obj5 = 0 ;
33439 char *kwnames[] = {
33440 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33441 };
33442
33443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33445 if (SWIG_arg_fail(1)) SWIG_fail;
33446 {
33447 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33448 if (SWIG_arg_fail(2)) SWIG_fail;
33449 }
33450 {
33451 arg3 = (int)(SWIG_As_int(obj2));
33452 if (SWIG_arg_fail(3)) SWIG_fail;
33453 }
33454 {
33455 arg4 = wxString_in_helper(obj3);
33456 if (arg4 == NULL) SWIG_fail;
33457 temp4 = true;
33458 }
33459 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33460 if (SWIG_arg_fail(5)) SWIG_fail;
33461 if (obj5) {
33462 {
33463 arg6 = wxString_in_helper(obj5);
33464 if (arg6 == NULL) SWIG_fail;
33465 temp6 = true;
33466 }
33467 }
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33471
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 {
33476 resultobj = wxPyMake_wxObject(result, 0);
33477 }
33478 {
33479 if (temp4)
33480 delete arg4;
33481 }
33482 {
33483 if (temp6)
33484 delete arg6;
33485 }
33486 return resultobj;
33487 fail:
33488 {
33489 if (temp4)
33490 delete arg4;
33491 }
33492 {
33493 if (temp6)
33494 delete arg6;
33495 }
33496 return NULL;
33497 }
33498
33499
33500 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33501 PyObject *resultobj;
33502 wxMenu *arg1 = (wxMenu *) 0 ;
33503 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33504 wxMenuItem *result;
33505 PyObject * obj0 = 0 ;
33506 PyObject * obj1 = 0 ;
33507 char *kwnames[] = {
33508 (char *) "self",(char *) "item", NULL
33509 };
33510
33511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33513 if (SWIG_arg_fail(1)) SWIG_fail;
33514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33515 if (SWIG_arg_fail(2)) SWIG_fail;
33516 {
33517 PyThreadState* __tstate = wxPyBeginAllowThreads();
33518 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33519
33520 wxPyEndAllowThreads(__tstate);
33521 if (PyErr_Occurred()) SWIG_fail;
33522 }
33523 {
33524 resultobj = wxPyMake_wxObject(result, 0);
33525 }
33526 return resultobj;
33527 fail:
33528 return NULL;
33529 }
33530
33531
33532 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj;
33534 wxMenu *arg1 = (wxMenu *) 0 ;
33535 int arg2 ;
33536 wxString *arg3 = 0 ;
33537 wxString const &arg4_defvalue = wxPyEmptyString ;
33538 wxString *arg4 = (wxString *) &arg4_defvalue ;
33539 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33540 wxMenuItem *result;
33541 bool temp3 = false ;
33542 bool temp4 = false ;
33543 PyObject * obj0 = 0 ;
33544 PyObject * obj1 = 0 ;
33545 PyObject * obj2 = 0 ;
33546 PyObject * obj3 = 0 ;
33547 PyObject * obj4 = 0 ;
33548 char *kwnames[] = {
33549 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33550 };
33551
33552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33554 if (SWIG_arg_fail(1)) SWIG_fail;
33555 {
33556 arg2 = (int)(SWIG_As_int(obj1));
33557 if (SWIG_arg_fail(2)) SWIG_fail;
33558 }
33559 {
33560 arg3 = wxString_in_helper(obj2);
33561 if (arg3 == NULL) SWIG_fail;
33562 temp3 = true;
33563 }
33564 if (obj3) {
33565 {
33566 arg4 = wxString_in_helper(obj3);
33567 if (arg4 == NULL) SWIG_fail;
33568 temp4 = true;
33569 }
33570 }
33571 if (obj4) {
33572 {
33573 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33574 if (SWIG_arg_fail(5)) SWIG_fail;
33575 }
33576 }
33577 {
33578 PyThreadState* __tstate = wxPyBeginAllowThreads();
33579 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33580
33581 wxPyEndAllowThreads(__tstate);
33582 if (PyErr_Occurred()) SWIG_fail;
33583 }
33584 {
33585 resultobj = wxPyMake_wxObject(result, 0);
33586 }
33587 {
33588 if (temp3)
33589 delete arg3;
33590 }
33591 {
33592 if (temp4)
33593 delete arg4;
33594 }
33595 return resultobj;
33596 fail:
33597 {
33598 if (temp3)
33599 delete arg3;
33600 }
33601 {
33602 if (temp4)
33603 delete arg4;
33604 }
33605 return NULL;
33606 }
33607
33608
33609 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33610 PyObject *resultobj;
33611 wxMenu *arg1 = (wxMenu *) 0 ;
33612 wxMenuItem *result;
33613 PyObject * obj0 = 0 ;
33614 char *kwnames[] = {
33615 (char *) "self", NULL
33616 };
33617
33618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33620 if (SWIG_arg_fail(1)) SWIG_fail;
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 result = (wxMenuItem *)(arg1)->PrependSeparator();
33624
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 {
33629 resultobj = wxPyMake_wxObject(result, 0);
33630 }
33631 return resultobj;
33632 fail:
33633 return NULL;
33634 }
33635
33636
33637 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33638 PyObject *resultobj;
33639 wxMenu *arg1 = (wxMenu *) 0 ;
33640 int arg2 ;
33641 wxString *arg3 = 0 ;
33642 wxString const &arg4_defvalue = wxPyEmptyString ;
33643 wxString *arg4 = (wxString *) &arg4_defvalue ;
33644 wxMenuItem *result;
33645 bool temp3 = false ;
33646 bool temp4 = false ;
33647 PyObject * obj0 = 0 ;
33648 PyObject * obj1 = 0 ;
33649 PyObject * obj2 = 0 ;
33650 PyObject * obj3 = 0 ;
33651 char *kwnames[] = {
33652 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33653 };
33654
33655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33657 if (SWIG_arg_fail(1)) SWIG_fail;
33658 {
33659 arg2 = (int)(SWIG_As_int(obj1));
33660 if (SWIG_arg_fail(2)) SWIG_fail;
33661 }
33662 {
33663 arg3 = wxString_in_helper(obj2);
33664 if (arg3 == NULL) SWIG_fail;
33665 temp3 = true;
33666 }
33667 if (obj3) {
33668 {
33669 arg4 = wxString_in_helper(obj3);
33670 if (arg4 == NULL) SWIG_fail;
33671 temp4 = true;
33672 }
33673 }
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33677
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 {
33682 resultobj = wxPyMake_wxObject(result, 0);
33683 }
33684 {
33685 if (temp3)
33686 delete arg3;
33687 }
33688 {
33689 if (temp4)
33690 delete arg4;
33691 }
33692 return resultobj;
33693 fail:
33694 {
33695 if (temp3)
33696 delete arg3;
33697 }
33698 {
33699 if (temp4)
33700 delete arg4;
33701 }
33702 return NULL;
33703 }
33704
33705
33706 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33707 PyObject *resultobj;
33708 wxMenu *arg1 = (wxMenu *) 0 ;
33709 int arg2 ;
33710 wxString *arg3 = 0 ;
33711 wxString const &arg4_defvalue = wxPyEmptyString ;
33712 wxString *arg4 = (wxString *) &arg4_defvalue ;
33713 wxMenuItem *result;
33714 bool temp3 = false ;
33715 bool temp4 = false ;
33716 PyObject * obj0 = 0 ;
33717 PyObject * obj1 = 0 ;
33718 PyObject * obj2 = 0 ;
33719 PyObject * obj3 = 0 ;
33720 char *kwnames[] = {
33721 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33722 };
33723
33724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33726 if (SWIG_arg_fail(1)) SWIG_fail;
33727 {
33728 arg2 = (int)(SWIG_As_int(obj1));
33729 if (SWIG_arg_fail(2)) SWIG_fail;
33730 }
33731 {
33732 arg3 = wxString_in_helper(obj2);
33733 if (arg3 == NULL) SWIG_fail;
33734 temp3 = true;
33735 }
33736 if (obj3) {
33737 {
33738 arg4 = wxString_in_helper(obj3);
33739 if (arg4 == NULL) SWIG_fail;
33740 temp4 = true;
33741 }
33742 }
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33746
33747 wxPyEndAllowThreads(__tstate);
33748 if (PyErr_Occurred()) SWIG_fail;
33749 }
33750 {
33751 resultobj = wxPyMake_wxObject(result, 0);
33752 }
33753 {
33754 if (temp3)
33755 delete arg3;
33756 }
33757 {
33758 if (temp4)
33759 delete arg4;
33760 }
33761 return resultobj;
33762 fail:
33763 {
33764 if (temp3)
33765 delete arg3;
33766 }
33767 {
33768 if (temp4)
33769 delete arg4;
33770 }
33771 return NULL;
33772 }
33773
33774
33775 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj;
33777 wxMenu *arg1 = (wxMenu *) 0 ;
33778 int arg2 ;
33779 wxString *arg3 = 0 ;
33780 wxMenu *arg4 = (wxMenu *) 0 ;
33781 wxString const &arg5_defvalue = wxPyEmptyString ;
33782 wxString *arg5 = (wxString *) &arg5_defvalue ;
33783 wxMenuItem *result;
33784 bool temp3 = false ;
33785 bool temp5 = false ;
33786 PyObject * obj0 = 0 ;
33787 PyObject * obj1 = 0 ;
33788 PyObject * obj2 = 0 ;
33789 PyObject * obj3 = 0 ;
33790 PyObject * obj4 = 0 ;
33791 char *kwnames[] = {
33792 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33793 };
33794
33795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33797 if (SWIG_arg_fail(1)) SWIG_fail;
33798 {
33799 arg2 = (int)(SWIG_As_int(obj1));
33800 if (SWIG_arg_fail(2)) SWIG_fail;
33801 }
33802 {
33803 arg3 = wxString_in_helper(obj2);
33804 if (arg3 == NULL) SWIG_fail;
33805 temp3 = true;
33806 }
33807 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33808 if (SWIG_arg_fail(4)) SWIG_fail;
33809 if (obj4) {
33810 {
33811 arg5 = wxString_in_helper(obj4);
33812 if (arg5 == NULL) SWIG_fail;
33813 temp5 = true;
33814 }
33815 }
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33819
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 {
33824 resultobj = wxPyMake_wxObject(result, 0);
33825 }
33826 {
33827 if (temp3)
33828 delete arg3;
33829 }
33830 {
33831 if (temp5)
33832 delete arg5;
33833 }
33834 return resultobj;
33835 fail:
33836 {
33837 if (temp3)
33838 delete arg3;
33839 }
33840 {
33841 if (temp5)
33842 delete arg5;
33843 }
33844 return NULL;
33845 }
33846
33847
33848 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33849 PyObject *resultobj;
33850 wxMenu *arg1 = (wxMenu *) 0 ;
33851 int arg2 ;
33852 wxMenuItem *result;
33853 PyObject * obj0 = 0 ;
33854 PyObject * obj1 = 0 ;
33855 char *kwnames[] = {
33856 (char *) "self",(char *) "id", NULL
33857 };
33858
33859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33861 if (SWIG_arg_fail(1)) SWIG_fail;
33862 {
33863 arg2 = (int)(SWIG_As_int(obj1));
33864 if (SWIG_arg_fail(2)) SWIG_fail;
33865 }
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 result = (wxMenuItem *)(arg1)->Remove(arg2);
33869
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 {
33874 resultobj = wxPyMake_wxObject(result, 0);
33875 }
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33886 wxMenuItem *result;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char *kwnames[] = {
33890 (char *) "self",(char *) "item", NULL
33891 };
33892
33893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33895 if (SWIG_arg_fail(1)) SWIG_fail;
33896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33897 if (SWIG_arg_fail(2)) SWIG_fail;
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (wxMenuItem *)(arg1)->Remove(arg2);
33901
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = wxPyMake_wxObject(result, 0);
33907 }
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33915 PyObject *resultobj;
33916 wxMenu *arg1 = (wxMenu *) 0 ;
33917 int arg2 ;
33918 bool result;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 char *kwnames[] = {
33922 (char *) "self",(char *) "id", NULL
33923 };
33924
33925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33927 if (SWIG_arg_fail(1)) SWIG_fail;
33928 {
33929 arg2 = (int)(SWIG_As_int(obj1));
33930 if (SWIG_arg_fail(2)) SWIG_fail;
33931 }
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 result = (bool)(arg1)->Delete(arg2);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 {
33940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33941 }
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj;
33950 wxMenu *arg1 = (wxMenu *) 0 ;
33951 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33952 bool result;
33953 PyObject * obj0 = 0 ;
33954 PyObject * obj1 = 0 ;
33955 char *kwnames[] = {
33956 (char *) "self",(char *) "item", NULL
33957 };
33958
33959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33961 if (SWIG_arg_fail(1)) SWIG_fail;
33962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33963 if (SWIG_arg_fail(2)) SWIG_fail;
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (bool)(arg1)->Delete(arg2);
33967
33968 wxPyEndAllowThreads(__tstate);
33969 if (PyErr_Occurred()) SWIG_fail;
33970 }
33971 {
33972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33973 }
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj;
33982 wxMenu *arg1 = (wxMenu *) 0 ;
33983 PyObject * obj0 = 0 ;
33984 char *kwnames[] = {
33985 (char *) "self", NULL
33986 };
33987
33988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33990 if (SWIG_arg_fail(1)) SWIG_fail;
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 wxMenu_Destroy(arg1);
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 Py_INCREF(Py_None); resultobj = Py_None;
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj;
34007 wxMenu *arg1 = (wxMenu *) 0 ;
34008 int arg2 ;
34009 bool result;
34010 PyObject * obj0 = 0 ;
34011 PyObject * obj1 = 0 ;
34012 char *kwnames[] = {
34013 (char *) "self",(char *) "id", NULL
34014 };
34015
34016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34018 if (SWIG_arg_fail(1)) SWIG_fail;
34019 {
34020 arg2 = (int)(SWIG_As_int(obj1));
34021 if (SWIG_arg_fail(2)) SWIG_fail;
34022 }
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (bool)(arg1)->Destroy(arg2);
34026
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 {
34031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34032 }
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34043 bool result;
34044 PyObject * obj0 = 0 ;
34045 PyObject * obj1 = 0 ;
34046 char *kwnames[] = {
34047 (char *) "self",(char *) "item", NULL
34048 };
34049
34050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34052 if (SWIG_arg_fail(1)) SWIG_fail;
34053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34054 if (SWIG_arg_fail(2)) SWIG_fail;
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = (bool)(arg1)->Destroy(arg2);
34058
34059 wxPyEndAllowThreads(__tstate);
34060 if (PyErr_Occurred()) SWIG_fail;
34061 }
34062 {
34063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34064 }
34065 return resultobj;
34066 fail:
34067 return NULL;
34068 }
34069
34070
34071 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34072 PyObject *resultobj;
34073 wxMenu *arg1 = (wxMenu *) 0 ;
34074 size_t result;
34075 PyObject * obj0 = 0 ;
34076 char *kwnames[] = {
34077 (char *) "self", NULL
34078 };
34079
34080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34082 if (SWIG_arg_fail(1)) SWIG_fail;
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34086
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 {
34091 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34092 }
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34100 PyObject *resultobj;
34101 wxMenu *arg1 = (wxMenu *) 0 ;
34102 PyObject *result;
34103 PyObject * obj0 = 0 ;
34104 char *kwnames[] = {
34105 (char *) "self", NULL
34106 };
34107
34108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34110 if (SWIG_arg_fail(1)) SWIG_fail;
34111 {
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34114
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 resultobj = result;
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj;
34127 wxMenu *arg1 = (wxMenu *) 0 ;
34128 wxString *arg2 = 0 ;
34129 int result;
34130 bool temp2 = false ;
34131 PyObject * obj0 = 0 ;
34132 PyObject * obj1 = 0 ;
34133 char *kwnames[] = {
34134 (char *) "self",(char *) "item", NULL
34135 };
34136
34137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34139 if (SWIG_arg_fail(1)) SWIG_fail;
34140 {
34141 arg2 = wxString_in_helper(obj1);
34142 if (arg2 == NULL) SWIG_fail;
34143 temp2 = true;
34144 }
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34148
34149 wxPyEndAllowThreads(__tstate);
34150 if (PyErr_Occurred()) SWIG_fail;
34151 }
34152 {
34153 resultobj = SWIG_From_int((int)(result));
34154 }
34155 {
34156 if (temp2)
34157 delete arg2;
34158 }
34159 return resultobj;
34160 fail:
34161 {
34162 if (temp2)
34163 delete arg2;
34164 }
34165 return NULL;
34166 }
34167
34168
34169 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34170 PyObject *resultobj;
34171 wxMenu *arg1 = (wxMenu *) 0 ;
34172 int arg2 ;
34173 wxMenuItem *result;
34174 PyObject * obj0 = 0 ;
34175 PyObject * obj1 = 0 ;
34176 char *kwnames[] = {
34177 (char *) "self",(char *) "id", NULL
34178 };
34179
34180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34182 if (SWIG_arg_fail(1)) SWIG_fail;
34183 {
34184 arg2 = (int)(SWIG_As_int(obj1));
34185 if (SWIG_arg_fail(2)) SWIG_fail;
34186 }
34187 {
34188 PyThreadState* __tstate = wxPyBeginAllowThreads();
34189 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34190
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 {
34195 resultobj = wxPyMake_wxObject(result, 0);
34196 }
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34204 PyObject *resultobj;
34205 wxMenu *arg1 = (wxMenu *) 0 ;
34206 size_t arg2 ;
34207 wxMenuItem *result;
34208 PyObject * obj0 = 0 ;
34209 PyObject * obj1 = 0 ;
34210 char *kwnames[] = {
34211 (char *) "self",(char *) "position", NULL
34212 };
34213
34214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34216 if (SWIG_arg_fail(1)) SWIG_fail;
34217 {
34218 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34219 if (SWIG_arg_fail(2)) SWIG_fail;
34220 }
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34224
34225 wxPyEndAllowThreads(__tstate);
34226 if (PyErr_Occurred()) SWIG_fail;
34227 }
34228 {
34229 resultobj = wxPyMake_wxObject(result, 0);
34230 }
34231 return resultobj;
34232 fail:
34233 return NULL;
34234 }
34235
34236
34237 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34238 PyObject *resultobj;
34239 wxMenu *arg1 = (wxMenu *) 0 ;
34240 int arg2 ;
34241 bool arg3 ;
34242 PyObject * obj0 = 0 ;
34243 PyObject * obj1 = 0 ;
34244 PyObject * obj2 = 0 ;
34245 char *kwnames[] = {
34246 (char *) "self",(char *) "id",(char *) "enable", NULL
34247 };
34248
34249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34251 if (SWIG_arg_fail(1)) SWIG_fail;
34252 {
34253 arg2 = (int)(SWIG_As_int(obj1));
34254 if (SWIG_arg_fail(2)) SWIG_fail;
34255 }
34256 {
34257 arg3 = (bool)(SWIG_As_bool(obj2));
34258 if (SWIG_arg_fail(3)) SWIG_fail;
34259 }
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 (arg1)->Enable(arg2,arg3);
34263
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 Py_INCREF(Py_None); resultobj = Py_None;
34268 return resultobj;
34269 fail:
34270 return NULL;
34271 }
34272
34273
34274 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34275 PyObject *resultobj;
34276 wxMenu *arg1 = (wxMenu *) 0 ;
34277 int arg2 ;
34278 bool result;
34279 PyObject * obj0 = 0 ;
34280 PyObject * obj1 = 0 ;
34281 char *kwnames[] = {
34282 (char *) "self",(char *) "id", NULL
34283 };
34284
34285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34287 if (SWIG_arg_fail(1)) SWIG_fail;
34288 {
34289 arg2 = (int)(SWIG_As_int(obj1));
34290 if (SWIG_arg_fail(2)) SWIG_fail;
34291 }
34292 {
34293 PyThreadState* __tstate = wxPyBeginAllowThreads();
34294 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34295
34296 wxPyEndAllowThreads(__tstate);
34297 if (PyErr_Occurred()) SWIG_fail;
34298 }
34299 {
34300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34301 }
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34309 PyObject *resultobj;
34310 wxMenu *arg1 = (wxMenu *) 0 ;
34311 int arg2 ;
34312 bool arg3 ;
34313 PyObject * obj0 = 0 ;
34314 PyObject * obj1 = 0 ;
34315 PyObject * obj2 = 0 ;
34316 char *kwnames[] = {
34317 (char *) "self",(char *) "id",(char *) "check", NULL
34318 };
34319
34320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34322 if (SWIG_arg_fail(1)) SWIG_fail;
34323 {
34324 arg2 = (int)(SWIG_As_int(obj1));
34325 if (SWIG_arg_fail(2)) SWIG_fail;
34326 }
34327 {
34328 arg3 = (bool)(SWIG_As_bool(obj2));
34329 if (SWIG_arg_fail(3)) SWIG_fail;
34330 }
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 (arg1)->Check(arg2,arg3);
34334
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 Py_INCREF(Py_None); resultobj = Py_None;
34339 return resultobj;
34340 fail:
34341 return NULL;
34342 }
34343
34344
34345 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj;
34347 wxMenu *arg1 = (wxMenu *) 0 ;
34348 int arg2 ;
34349 bool result;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 char *kwnames[] = {
34353 (char *) "self",(char *) "id", NULL
34354 };
34355
34356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34358 if (SWIG_arg_fail(1)) SWIG_fail;
34359 {
34360 arg2 = (int)(SWIG_As_int(obj1));
34361 if (SWIG_arg_fail(2)) SWIG_fail;
34362 }
34363 {
34364 PyThreadState* __tstate = wxPyBeginAllowThreads();
34365 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34366
34367 wxPyEndAllowThreads(__tstate);
34368 if (PyErr_Occurred()) SWIG_fail;
34369 }
34370 {
34371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34372 }
34373 return resultobj;
34374 fail:
34375 return NULL;
34376 }
34377
34378
34379 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34380 PyObject *resultobj;
34381 wxMenu *arg1 = (wxMenu *) 0 ;
34382 int arg2 ;
34383 wxString *arg3 = 0 ;
34384 bool temp3 = false ;
34385 PyObject * obj0 = 0 ;
34386 PyObject * obj1 = 0 ;
34387 PyObject * obj2 = 0 ;
34388 char *kwnames[] = {
34389 (char *) "self",(char *) "id",(char *) "label", NULL
34390 };
34391
34392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34394 if (SWIG_arg_fail(1)) SWIG_fail;
34395 {
34396 arg2 = (int)(SWIG_As_int(obj1));
34397 if (SWIG_arg_fail(2)) SWIG_fail;
34398 }
34399 {
34400 arg3 = wxString_in_helper(obj2);
34401 if (arg3 == NULL) SWIG_fail;
34402 temp3 = true;
34403 }
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34407
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 Py_INCREF(Py_None); resultobj = Py_None;
34412 {
34413 if (temp3)
34414 delete arg3;
34415 }
34416 return resultobj;
34417 fail:
34418 {
34419 if (temp3)
34420 delete arg3;
34421 }
34422 return NULL;
34423 }
34424
34425
34426 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34427 PyObject *resultobj;
34428 wxMenu *arg1 = (wxMenu *) 0 ;
34429 int arg2 ;
34430 wxString result;
34431 PyObject * obj0 = 0 ;
34432 PyObject * obj1 = 0 ;
34433 char *kwnames[] = {
34434 (char *) "self",(char *) "id", NULL
34435 };
34436
34437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34439 if (SWIG_arg_fail(1)) SWIG_fail;
34440 {
34441 arg2 = (int)(SWIG_As_int(obj1));
34442 if (SWIG_arg_fail(2)) SWIG_fail;
34443 }
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34447
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 {
34452 #if wxUSE_UNICODE
34453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34454 #else
34455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34456 #endif
34457 }
34458 return resultobj;
34459 fail:
34460 return NULL;
34461 }
34462
34463
34464 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34465 PyObject *resultobj;
34466 wxMenu *arg1 = (wxMenu *) 0 ;
34467 int arg2 ;
34468 wxString *arg3 = 0 ;
34469 bool temp3 = false ;
34470 PyObject * obj0 = 0 ;
34471 PyObject * obj1 = 0 ;
34472 PyObject * obj2 = 0 ;
34473 char *kwnames[] = {
34474 (char *) "self",(char *) "id",(char *) "helpString", NULL
34475 };
34476
34477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34479 if (SWIG_arg_fail(1)) SWIG_fail;
34480 {
34481 arg2 = (int)(SWIG_As_int(obj1));
34482 if (SWIG_arg_fail(2)) SWIG_fail;
34483 }
34484 {
34485 arg3 = wxString_in_helper(obj2);
34486 if (arg3 == NULL) SWIG_fail;
34487 temp3 = true;
34488 }
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34492
34493 wxPyEndAllowThreads(__tstate);
34494 if (PyErr_Occurred()) SWIG_fail;
34495 }
34496 Py_INCREF(Py_None); resultobj = Py_None;
34497 {
34498 if (temp3)
34499 delete arg3;
34500 }
34501 return resultobj;
34502 fail:
34503 {
34504 if (temp3)
34505 delete arg3;
34506 }
34507 return NULL;
34508 }
34509
34510
34511 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34512 PyObject *resultobj;
34513 wxMenu *arg1 = (wxMenu *) 0 ;
34514 int arg2 ;
34515 wxString result;
34516 PyObject * obj0 = 0 ;
34517 PyObject * obj1 = 0 ;
34518 char *kwnames[] = {
34519 (char *) "self",(char *) "id", NULL
34520 };
34521
34522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34524 if (SWIG_arg_fail(1)) SWIG_fail;
34525 {
34526 arg2 = (int)(SWIG_As_int(obj1));
34527 if (SWIG_arg_fail(2)) SWIG_fail;
34528 }
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34532
34533 wxPyEndAllowThreads(__tstate);
34534 if (PyErr_Occurred()) SWIG_fail;
34535 }
34536 {
34537 #if wxUSE_UNICODE
34538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34539 #else
34540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34541 #endif
34542 }
34543 return resultobj;
34544 fail:
34545 return NULL;
34546 }
34547
34548
34549 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34550 PyObject *resultobj;
34551 wxMenu *arg1 = (wxMenu *) 0 ;
34552 wxString *arg2 = 0 ;
34553 bool temp2 = false ;
34554 PyObject * obj0 = 0 ;
34555 PyObject * obj1 = 0 ;
34556 char *kwnames[] = {
34557 (char *) "self",(char *) "title", NULL
34558 };
34559
34560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34562 if (SWIG_arg_fail(1)) SWIG_fail;
34563 {
34564 arg2 = wxString_in_helper(obj1);
34565 if (arg2 == NULL) SWIG_fail;
34566 temp2 = true;
34567 }
34568 {
34569 PyThreadState* __tstate = wxPyBeginAllowThreads();
34570 (arg1)->SetTitle((wxString const &)*arg2);
34571
34572 wxPyEndAllowThreads(__tstate);
34573 if (PyErr_Occurred()) SWIG_fail;
34574 }
34575 Py_INCREF(Py_None); resultobj = Py_None;
34576 {
34577 if (temp2)
34578 delete arg2;
34579 }
34580 return resultobj;
34581 fail:
34582 {
34583 if (temp2)
34584 delete arg2;
34585 }
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenu *arg1 = (wxMenu *) 0 ;
34593 wxString result;
34594 PyObject * obj0 = 0 ;
34595 char *kwnames[] = {
34596 (char *) "self", NULL
34597 };
34598
34599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34601 if (SWIG_arg_fail(1)) SWIG_fail;
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = ((wxMenu const *)arg1)->GetTitle();
34605
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 {
34610 #if wxUSE_UNICODE
34611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34612 #else
34613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34614 #endif
34615 }
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34623 PyObject *resultobj;
34624 wxMenu *arg1 = (wxMenu *) 0 ;
34625 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34626 PyObject * obj0 = 0 ;
34627 PyObject * obj1 = 0 ;
34628 char *kwnames[] = {
34629 (char *) "self",(char *) "handler", NULL
34630 };
34631
34632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34634 if (SWIG_arg_fail(1)) SWIG_fail;
34635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34636 if (SWIG_arg_fail(2)) SWIG_fail;
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 (arg1)->SetEventHandler(arg2);
34640
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 Py_INCREF(Py_None); resultobj = Py_None;
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj;
34653 wxMenu *arg1 = (wxMenu *) 0 ;
34654 wxEvtHandler *result;
34655 PyObject * obj0 = 0 ;
34656 char *kwnames[] = {
34657 (char *) "self", NULL
34658 };
34659
34660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34662 if (SWIG_arg_fail(1)) SWIG_fail;
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34666
34667 wxPyEndAllowThreads(__tstate);
34668 if (PyErr_Occurred()) SWIG_fail;
34669 }
34670 {
34671 resultobj = wxPyMake_wxObject(result, 0);
34672 }
34673 return resultobj;
34674 fail:
34675 return NULL;
34676 }
34677
34678
34679 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34680 PyObject *resultobj;
34681 wxMenu *arg1 = (wxMenu *) 0 ;
34682 wxWindow *arg2 = (wxWindow *) 0 ;
34683 PyObject * obj0 = 0 ;
34684 PyObject * obj1 = 0 ;
34685 char *kwnames[] = {
34686 (char *) "self",(char *) "win", NULL
34687 };
34688
34689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34691 if (SWIG_arg_fail(1)) SWIG_fail;
34692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34693 if (SWIG_arg_fail(2)) SWIG_fail;
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 (arg1)->SetInvokingWindow(arg2);
34697
34698 wxPyEndAllowThreads(__tstate);
34699 if (PyErr_Occurred()) SWIG_fail;
34700 }
34701 Py_INCREF(Py_None); resultobj = Py_None;
34702 return resultobj;
34703 fail:
34704 return NULL;
34705 }
34706
34707
34708 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34709 PyObject *resultobj;
34710 wxMenu *arg1 = (wxMenu *) 0 ;
34711 wxWindow *result;
34712 PyObject * obj0 = 0 ;
34713 char *kwnames[] = {
34714 (char *) "self", NULL
34715 };
34716
34717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34719 if (SWIG_arg_fail(1)) SWIG_fail;
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34723
34724 wxPyEndAllowThreads(__tstate);
34725 if (PyErr_Occurred()) SWIG_fail;
34726 }
34727 {
34728 resultobj = wxPyMake_wxObject(result, 0);
34729 }
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34737 PyObject *resultobj;
34738 wxMenu *arg1 = (wxMenu *) 0 ;
34739 long result;
34740 PyObject * obj0 = 0 ;
34741 char *kwnames[] = {
34742 (char *) "self", NULL
34743 };
34744
34745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34747 if (SWIG_arg_fail(1)) SWIG_fail;
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = (long)((wxMenu const *)arg1)->GetStyle();
34751
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 {
34756 resultobj = SWIG_From_long((long)(result));
34757 }
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj;
34766 wxMenu *arg1 = (wxMenu *) 0 ;
34767 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34768 PyObject * obj0 = 0 ;
34769 PyObject * obj1 = 0 ;
34770 char *kwnames[] = {
34771 (char *) "self",(char *) "source", NULL
34772 };
34773
34774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34776 if (SWIG_arg_fail(1)) SWIG_fail;
34777 if (obj1) {
34778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34779 if (SWIG_arg_fail(2)) SWIG_fail;
34780 }
34781 {
34782 PyThreadState* __tstate = wxPyBeginAllowThreads();
34783 (arg1)->UpdateUI(arg2);
34784
34785 wxPyEndAllowThreads(__tstate);
34786 if (PyErr_Occurred()) SWIG_fail;
34787 }
34788 Py_INCREF(Py_None); resultobj = Py_None;
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34796 PyObject *resultobj;
34797 wxMenu *arg1 = (wxMenu *) 0 ;
34798 wxMenuBar *result;
34799 PyObject * obj0 = 0 ;
34800 char *kwnames[] = {
34801 (char *) "self", NULL
34802 };
34803
34804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34806 if (SWIG_arg_fail(1)) SWIG_fail;
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34810
34811 wxPyEndAllowThreads(__tstate);
34812 if (PyErr_Occurred()) SWIG_fail;
34813 }
34814 {
34815 resultobj = wxPyMake_wxObject(result, 0);
34816 }
34817 return resultobj;
34818 fail:
34819 return NULL;
34820 }
34821
34822
34823 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34824 PyObject *resultobj;
34825 wxMenu *arg1 = (wxMenu *) 0 ;
34826 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34827 PyObject * obj0 = 0 ;
34828 PyObject * obj1 = 0 ;
34829 char *kwnames[] = {
34830 (char *) "self",(char *) "menubar", NULL
34831 };
34832
34833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34835 if (SWIG_arg_fail(1)) SWIG_fail;
34836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(2)) SWIG_fail;
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 (arg1)->Attach(arg2);
34841
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 Py_INCREF(Py_None); resultobj = Py_None;
34846 return resultobj;
34847 fail:
34848 return NULL;
34849 }
34850
34851
34852 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34853 PyObject *resultobj;
34854 wxMenu *arg1 = (wxMenu *) 0 ;
34855 PyObject * obj0 = 0 ;
34856 char *kwnames[] = {
34857 (char *) "self", NULL
34858 };
34859
34860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34862 if (SWIG_arg_fail(1)) SWIG_fail;
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 (arg1)->Detach();
34866
34867 wxPyEndAllowThreads(__tstate);
34868 if (PyErr_Occurred()) SWIG_fail;
34869 }
34870 Py_INCREF(Py_None); resultobj = Py_None;
34871 return resultobj;
34872 fail:
34873 return NULL;
34874 }
34875
34876
34877 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34878 PyObject *resultobj;
34879 wxMenu *arg1 = (wxMenu *) 0 ;
34880 bool result;
34881 PyObject * obj0 = 0 ;
34882 char *kwnames[] = {
34883 (char *) "self", NULL
34884 };
34885
34886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34888 if (SWIG_arg_fail(1)) SWIG_fail;
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 result = (bool)((wxMenu const *)arg1)->IsAttached();
34892
34893 wxPyEndAllowThreads(__tstate);
34894 if (PyErr_Occurred()) SWIG_fail;
34895 }
34896 {
34897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34898 }
34899 return resultobj;
34900 fail:
34901 return NULL;
34902 }
34903
34904
34905 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34906 PyObject *resultobj;
34907 wxMenu *arg1 = (wxMenu *) 0 ;
34908 wxMenu *arg2 = (wxMenu *) 0 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 char *kwnames[] = {
34912 (char *) "self",(char *) "parent", NULL
34913 };
34914
34915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34917 if (SWIG_arg_fail(1)) SWIG_fail;
34918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34919 if (SWIG_arg_fail(2)) SWIG_fail;
34920 {
34921 PyThreadState* __tstate = wxPyBeginAllowThreads();
34922 (arg1)->SetParent(arg2);
34923
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 Py_INCREF(Py_None); resultobj = Py_None;
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34935 PyObject *resultobj;
34936 wxMenu *arg1 = (wxMenu *) 0 ;
34937 wxMenu *result;
34938 PyObject * obj0 = 0 ;
34939 char *kwnames[] = {
34940 (char *) "self", NULL
34941 };
34942
34943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34945 if (SWIG_arg_fail(1)) SWIG_fail;
34946 {
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34949
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 {
34954 resultobj = wxPyMake_wxObject(result, 0);
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34963 PyObject *obj;
34964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34965 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34966 Py_INCREF(obj);
34967 return Py_BuildValue((char *)"");
34968 }
34969 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34970 PyObject *resultobj;
34971 long arg1 = (long) 0 ;
34972 wxMenuBar *result;
34973 PyObject * obj0 = 0 ;
34974 char *kwnames[] = {
34975 (char *) "style", NULL
34976 };
34977
34978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34979 if (obj0) {
34980 {
34981 arg1 = (long)(SWIG_As_long(obj0));
34982 if (SWIG_arg_fail(1)) SWIG_fail;
34983 }
34984 }
34985 {
34986 if (!wxPyCheckForApp()) SWIG_fail;
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 result = (wxMenuBar *)new wxMenuBar(arg1);
34989
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35001 PyObject *resultobj;
35002 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35003 wxMenu *arg2 = (wxMenu *) 0 ;
35004 wxString *arg3 = 0 ;
35005 bool result;
35006 bool temp3 = false ;
35007 PyObject * obj0 = 0 ;
35008 PyObject * obj1 = 0 ;
35009 PyObject * obj2 = 0 ;
35010 char *kwnames[] = {
35011 (char *) "self",(char *) "menu",(char *) "title", NULL
35012 };
35013
35014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35016 if (SWIG_arg_fail(1)) SWIG_fail;
35017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(2)) SWIG_fail;
35019 {
35020 arg3 = wxString_in_helper(obj2);
35021 if (arg3 == NULL) SWIG_fail;
35022 temp3 = true;
35023 }
35024 {
35025 PyThreadState* __tstate = wxPyBeginAllowThreads();
35026 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35027
35028 wxPyEndAllowThreads(__tstate);
35029 if (PyErr_Occurred()) SWIG_fail;
35030 }
35031 {
35032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35033 }
35034 {
35035 if (temp3)
35036 delete arg3;
35037 }
35038 return resultobj;
35039 fail:
35040 {
35041 if (temp3)
35042 delete arg3;
35043 }
35044 return NULL;
35045 }
35046
35047
35048 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj;
35050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35051 size_t arg2 ;
35052 wxMenu *arg3 = (wxMenu *) 0 ;
35053 wxString *arg4 = 0 ;
35054 bool result;
35055 bool temp4 = false ;
35056 PyObject * obj0 = 0 ;
35057 PyObject * obj1 = 0 ;
35058 PyObject * obj2 = 0 ;
35059 PyObject * obj3 = 0 ;
35060 char *kwnames[] = {
35061 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35062 };
35063
35064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35066 if (SWIG_arg_fail(1)) SWIG_fail;
35067 {
35068 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35069 if (SWIG_arg_fail(2)) SWIG_fail;
35070 }
35071 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35072 if (SWIG_arg_fail(3)) SWIG_fail;
35073 {
35074 arg4 = wxString_in_helper(obj3);
35075 if (arg4 == NULL) SWIG_fail;
35076 temp4 = true;
35077 }
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35081
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 {
35086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35087 }
35088 {
35089 if (temp4)
35090 delete arg4;
35091 }
35092 return resultobj;
35093 fail:
35094 {
35095 if (temp4)
35096 delete arg4;
35097 }
35098 return NULL;
35099 }
35100
35101
35102 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35103 PyObject *resultobj;
35104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35105 size_t result;
35106 PyObject * obj0 = 0 ;
35107 char *kwnames[] = {
35108 (char *) "self", NULL
35109 };
35110
35111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35113 if (SWIG_arg_fail(1)) SWIG_fail;
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35117
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 {
35122 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35123 }
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj;
35132 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35133 size_t arg2 ;
35134 wxMenu *result;
35135 PyObject * obj0 = 0 ;
35136 PyObject * obj1 = 0 ;
35137 char *kwnames[] = {
35138 (char *) "self",(char *) "pos", NULL
35139 };
35140
35141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35143 if (SWIG_arg_fail(1)) SWIG_fail;
35144 {
35145 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35146 if (SWIG_arg_fail(2)) SWIG_fail;
35147 }
35148 {
35149 PyThreadState* __tstate = wxPyBeginAllowThreads();
35150 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35151
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 {
35156 resultobj = wxPyMake_wxObject(result, 0);
35157 }
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj;
35166 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35167 size_t arg2 ;
35168 wxMenu *arg3 = (wxMenu *) 0 ;
35169 wxString *arg4 = 0 ;
35170 wxMenu *result;
35171 bool temp4 = false ;
35172 PyObject * obj0 = 0 ;
35173 PyObject * obj1 = 0 ;
35174 PyObject * obj2 = 0 ;
35175 PyObject * obj3 = 0 ;
35176 char *kwnames[] = {
35177 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35178 };
35179
35180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35182 if (SWIG_arg_fail(1)) SWIG_fail;
35183 {
35184 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35185 if (SWIG_arg_fail(2)) SWIG_fail;
35186 }
35187 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35188 if (SWIG_arg_fail(3)) SWIG_fail;
35189 {
35190 arg4 = wxString_in_helper(obj3);
35191 if (arg4 == NULL) SWIG_fail;
35192 temp4 = true;
35193 }
35194 {
35195 PyThreadState* __tstate = wxPyBeginAllowThreads();
35196 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35197
35198 wxPyEndAllowThreads(__tstate);
35199 if (PyErr_Occurred()) SWIG_fail;
35200 }
35201 {
35202 resultobj = wxPyMake_wxObject(result, 0);
35203 }
35204 {
35205 if (temp4)
35206 delete arg4;
35207 }
35208 return resultobj;
35209 fail:
35210 {
35211 if (temp4)
35212 delete arg4;
35213 }
35214 return NULL;
35215 }
35216
35217
35218 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35219 PyObject *resultobj;
35220 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35221 size_t arg2 ;
35222 wxMenu *result;
35223 PyObject * obj0 = 0 ;
35224 PyObject * obj1 = 0 ;
35225 char *kwnames[] = {
35226 (char *) "self",(char *) "pos", NULL
35227 };
35228
35229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35231 if (SWIG_arg_fail(1)) SWIG_fail;
35232 {
35233 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35234 if (SWIG_arg_fail(2)) SWIG_fail;
35235 }
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 result = (wxMenu *)(arg1)->Remove(arg2);
35239
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 {
35244 resultobj = wxPyMake_wxObject(result, 0);
35245 }
35246 return resultobj;
35247 fail:
35248 return NULL;
35249 }
35250
35251
35252 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35253 PyObject *resultobj;
35254 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35255 size_t arg2 ;
35256 bool arg3 ;
35257 PyObject * obj0 = 0 ;
35258 PyObject * obj1 = 0 ;
35259 PyObject * obj2 = 0 ;
35260 char *kwnames[] = {
35261 (char *) "self",(char *) "pos",(char *) "enable", NULL
35262 };
35263
35264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35266 if (SWIG_arg_fail(1)) SWIG_fail;
35267 {
35268 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35269 if (SWIG_arg_fail(2)) SWIG_fail;
35270 }
35271 {
35272 arg3 = (bool)(SWIG_As_bool(obj2));
35273 if (SWIG_arg_fail(3)) SWIG_fail;
35274 }
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 (arg1)->EnableTop(arg2,arg3);
35278
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 Py_INCREF(Py_None); resultobj = Py_None;
35283 return resultobj;
35284 fail:
35285 return NULL;
35286 }
35287
35288
35289 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35290 PyObject *resultobj;
35291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35292 size_t arg2 ;
35293 bool result;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 char *kwnames[] = {
35297 (char *) "self",(char *) "pos", NULL
35298 };
35299
35300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35302 if (SWIG_arg_fail(1)) SWIG_fail;
35303 {
35304 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35305 if (SWIG_arg_fail(2)) SWIG_fail;
35306 }
35307 {
35308 PyThreadState* __tstate = wxPyBeginAllowThreads();
35309 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35310
35311 wxPyEndAllowThreads(__tstate);
35312 if (PyErr_Occurred()) SWIG_fail;
35313 }
35314 {
35315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35316 }
35317 return resultobj;
35318 fail:
35319 return NULL;
35320 }
35321
35322
35323 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35324 PyObject *resultobj;
35325 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35326 size_t arg2 ;
35327 wxString *arg3 = 0 ;
35328 bool temp3 = false ;
35329 PyObject * obj0 = 0 ;
35330 PyObject * obj1 = 0 ;
35331 PyObject * obj2 = 0 ;
35332 char *kwnames[] = {
35333 (char *) "self",(char *) "pos",(char *) "label", NULL
35334 };
35335
35336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35338 if (SWIG_arg_fail(1)) SWIG_fail;
35339 {
35340 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35341 if (SWIG_arg_fail(2)) SWIG_fail;
35342 }
35343 {
35344 arg3 = wxString_in_helper(obj2);
35345 if (arg3 == NULL) SWIG_fail;
35346 temp3 = true;
35347 }
35348 {
35349 PyThreadState* __tstate = wxPyBeginAllowThreads();
35350 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35351
35352 wxPyEndAllowThreads(__tstate);
35353 if (PyErr_Occurred()) SWIG_fail;
35354 }
35355 Py_INCREF(Py_None); resultobj = Py_None;
35356 {
35357 if (temp3)
35358 delete arg3;
35359 }
35360 return resultobj;
35361 fail:
35362 {
35363 if (temp3)
35364 delete arg3;
35365 }
35366 return NULL;
35367 }
35368
35369
35370 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35371 PyObject *resultobj;
35372 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35373 size_t arg2 ;
35374 wxString result;
35375 PyObject * obj0 = 0 ;
35376 PyObject * obj1 = 0 ;
35377 char *kwnames[] = {
35378 (char *) "self",(char *) "pos", NULL
35379 };
35380
35381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35383 if (SWIG_arg_fail(1)) SWIG_fail;
35384 {
35385 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35386 if (SWIG_arg_fail(2)) SWIG_fail;
35387 }
35388 {
35389 PyThreadState* __tstate = wxPyBeginAllowThreads();
35390 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35391
35392 wxPyEndAllowThreads(__tstate);
35393 if (PyErr_Occurred()) SWIG_fail;
35394 }
35395 {
35396 #if wxUSE_UNICODE
35397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35398 #else
35399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35400 #endif
35401 }
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35409 PyObject *resultobj;
35410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35411 wxString *arg2 = 0 ;
35412 wxString *arg3 = 0 ;
35413 int result;
35414 bool temp2 = false ;
35415 bool temp3 = false ;
35416 PyObject * obj0 = 0 ;
35417 PyObject * obj1 = 0 ;
35418 PyObject * obj2 = 0 ;
35419 char *kwnames[] = {
35420 (char *) "self",(char *) "menu",(char *) "item", NULL
35421 };
35422
35423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35425 if (SWIG_arg_fail(1)) SWIG_fail;
35426 {
35427 arg2 = wxString_in_helper(obj1);
35428 if (arg2 == NULL) SWIG_fail;
35429 temp2 = true;
35430 }
35431 {
35432 arg3 = wxString_in_helper(obj2);
35433 if (arg3 == NULL) SWIG_fail;
35434 temp3 = true;
35435 }
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35439
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 {
35444 resultobj = SWIG_From_int((int)(result));
35445 }
35446 {
35447 if (temp2)
35448 delete arg2;
35449 }
35450 {
35451 if (temp3)
35452 delete arg3;
35453 }
35454 return resultobj;
35455 fail:
35456 {
35457 if (temp2)
35458 delete arg2;
35459 }
35460 {
35461 if (temp3)
35462 delete arg3;
35463 }
35464 return NULL;
35465 }
35466
35467
35468 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35469 PyObject *resultobj;
35470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35471 int arg2 ;
35472 wxMenuItem *result;
35473 PyObject * obj0 = 0 ;
35474 PyObject * obj1 = 0 ;
35475 char *kwnames[] = {
35476 (char *) "self",(char *) "id", NULL
35477 };
35478
35479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35481 if (SWIG_arg_fail(1)) SWIG_fail;
35482 {
35483 arg2 = (int)(SWIG_As_int(obj1));
35484 if (SWIG_arg_fail(2)) SWIG_fail;
35485 }
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35489
35490 wxPyEndAllowThreads(__tstate);
35491 if (PyErr_Occurred()) SWIG_fail;
35492 }
35493 {
35494 resultobj = wxPyMake_wxObject(result, 0);
35495 }
35496 return resultobj;
35497 fail:
35498 return NULL;
35499 }
35500
35501
35502 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35503 PyObject *resultobj;
35504 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35505 wxString *arg2 = 0 ;
35506 int result;
35507 bool temp2 = false ;
35508 PyObject * obj0 = 0 ;
35509 PyObject * obj1 = 0 ;
35510 char *kwnames[] = {
35511 (char *) "self",(char *) "title", NULL
35512 };
35513
35514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35516 if (SWIG_arg_fail(1)) SWIG_fail;
35517 {
35518 arg2 = wxString_in_helper(obj1);
35519 if (arg2 == NULL) SWIG_fail;
35520 temp2 = true;
35521 }
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35525
35526 wxPyEndAllowThreads(__tstate);
35527 if (PyErr_Occurred()) SWIG_fail;
35528 }
35529 {
35530 resultobj = SWIG_From_int((int)(result));
35531 }
35532 {
35533 if (temp2)
35534 delete arg2;
35535 }
35536 return resultobj;
35537 fail:
35538 {
35539 if (temp2)
35540 delete arg2;
35541 }
35542 return NULL;
35543 }
35544
35545
35546 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35547 PyObject *resultobj;
35548 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35549 int arg2 ;
35550 bool arg3 ;
35551 PyObject * obj0 = 0 ;
35552 PyObject * obj1 = 0 ;
35553 PyObject * obj2 = 0 ;
35554 char *kwnames[] = {
35555 (char *) "self",(char *) "id",(char *) "enable", NULL
35556 };
35557
35558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35560 if (SWIG_arg_fail(1)) SWIG_fail;
35561 {
35562 arg2 = (int)(SWIG_As_int(obj1));
35563 if (SWIG_arg_fail(2)) SWIG_fail;
35564 }
35565 {
35566 arg3 = (bool)(SWIG_As_bool(obj2));
35567 if (SWIG_arg_fail(3)) SWIG_fail;
35568 }
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 (arg1)->Enable(arg2,arg3);
35572
35573 wxPyEndAllowThreads(__tstate);
35574 if (PyErr_Occurred()) SWIG_fail;
35575 }
35576 Py_INCREF(Py_None); resultobj = Py_None;
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35584 PyObject *resultobj;
35585 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35586 int arg2 ;
35587 bool arg3 ;
35588 PyObject * obj0 = 0 ;
35589 PyObject * obj1 = 0 ;
35590 PyObject * obj2 = 0 ;
35591 char *kwnames[] = {
35592 (char *) "self",(char *) "id",(char *) "check", NULL
35593 };
35594
35595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35597 if (SWIG_arg_fail(1)) SWIG_fail;
35598 {
35599 arg2 = (int)(SWIG_As_int(obj1));
35600 if (SWIG_arg_fail(2)) SWIG_fail;
35601 }
35602 {
35603 arg3 = (bool)(SWIG_As_bool(obj2));
35604 if (SWIG_arg_fail(3)) SWIG_fail;
35605 }
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 (arg1)->Check(arg2,arg3);
35609
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 Py_INCREF(Py_None); resultobj = Py_None;
35614 return resultobj;
35615 fail:
35616 return NULL;
35617 }
35618
35619
35620 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35621 PyObject *resultobj;
35622 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35623 int arg2 ;
35624 bool result;
35625 PyObject * obj0 = 0 ;
35626 PyObject * obj1 = 0 ;
35627 char *kwnames[] = {
35628 (char *) "self",(char *) "id", NULL
35629 };
35630
35631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35633 if (SWIG_arg_fail(1)) SWIG_fail;
35634 {
35635 arg2 = (int)(SWIG_As_int(obj1));
35636 if (SWIG_arg_fail(2)) SWIG_fail;
35637 }
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35641
35642 wxPyEndAllowThreads(__tstate);
35643 if (PyErr_Occurred()) SWIG_fail;
35644 }
35645 {
35646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35647 }
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35655 PyObject *resultobj;
35656 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35657 int arg2 ;
35658 bool result;
35659 PyObject * obj0 = 0 ;
35660 PyObject * obj1 = 0 ;
35661 char *kwnames[] = {
35662 (char *) "self",(char *) "id", NULL
35663 };
35664
35665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35667 if (SWIG_arg_fail(1)) SWIG_fail;
35668 {
35669 arg2 = (int)(SWIG_As_int(obj1));
35670 if (SWIG_arg_fail(2)) SWIG_fail;
35671 }
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35675
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 {
35680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35681 }
35682 return resultobj;
35683 fail:
35684 return NULL;
35685 }
35686
35687
35688 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35689 PyObject *resultobj;
35690 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35691 int arg2 ;
35692 wxString *arg3 = 0 ;
35693 bool temp3 = false ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 PyObject * obj2 = 0 ;
35697 char *kwnames[] = {
35698 (char *) "self",(char *) "id",(char *) "label", NULL
35699 };
35700
35701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35703 if (SWIG_arg_fail(1)) SWIG_fail;
35704 {
35705 arg2 = (int)(SWIG_As_int(obj1));
35706 if (SWIG_arg_fail(2)) SWIG_fail;
35707 }
35708 {
35709 arg3 = wxString_in_helper(obj2);
35710 if (arg3 == NULL) SWIG_fail;
35711 temp3 = true;
35712 }
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 Py_INCREF(Py_None); resultobj = Py_None;
35721 {
35722 if (temp3)
35723 delete arg3;
35724 }
35725 return resultobj;
35726 fail:
35727 {
35728 if (temp3)
35729 delete arg3;
35730 }
35731 return NULL;
35732 }
35733
35734
35735 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35736 PyObject *resultobj;
35737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35738 int arg2 ;
35739 wxString result;
35740 PyObject * obj0 = 0 ;
35741 PyObject * obj1 = 0 ;
35742 char *kwnames[] = {
35743 (char *) "self",(char *) "id", NULL
35744 };
35745
35746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35748 if (SWIG_arg_fail(1)) SWIG_fail;
35749 {
35750 arg2 = (int)(SWIG_As_int(obj1));
35751 if (SWIG_arg_fail(2)) SWIG_fail;
35752 }
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35756
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 #if wxUSE_UNICODE
35762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35763 #else
35764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35765 #endif
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35774 PyObject *resultobj;
35775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35776 int arg2 ;
35777 wxString *arg3 = 0 ;
35778 bool temp3 = false ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 PyObject * obj2 = 0 ;
35782 char *kwnames[] = {
35783 (char *) "self",(char *) "id",(char *) "helpString", NULL
35784 };
35785
35786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35788 if (SWIG_arg_fail(1)) SWIG_fail;
35789 {
35790 arg2 = (int)(SWIG_As_int(obj1));
35791 if (SWIG_arg_fail(2)) SWIG_fail;
35792 }
35793 {
35794 arg3 = wxString_in_helper(obj2);
35795 if (arg3 == NULL) SWIG_fail;
35796 temp3 = true;
35797 }
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35801
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 Py_INCREF(Py_None); resultobj = Py_None;
35806 {
35807 if (temp3)
35808 delete arg3;
35809 }
35810 return resultobj;
35811 fail:
35812 {
35813 if (temp3)
35814 delete arg3;
35815 }
35816 return NULL;
35817 }
35818
35819
35820 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj;
35822 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35823 int arg2 ;
35824 wxString result;
35825 PyObject * obj0 = 0 ;
35826 PyObject * obj1 = 0 ;
35827 char *kwnames[] = {
35828 (char *) "self",(char *) "id", NULL
35829 };
35830
35831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35833 if (SWIG_arg_fail(1)) SWIG_fail;
35834 {
35835 arg2 = (int)(SWIG_As_int(obj1));
35836 if (SWIG_arg_fail(2)) SWIG_fail;
35837 }
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35841
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 {
35846 #if wxUSE_UNICODE
35847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35848 #else
35849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35850 #endif
35851 }
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35859 PyObject *resultobj;
35860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35861 wxFrame *result;
35862 PyObject * obj0 = 0 ;
35863 char *kwnames[] = {
35864 (char *) "self", NULL
35865 };
35866
35867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",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 = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35873
35874 wxPyEndAllowThreads(__tstate);
35875 if (PyErr_Occurred()) SWIG_fail;
35876 }
35877 {
35878 resultobj = wxPyMake_wxObject(result, 0);
35879 }
35880 return resultobj;
35881 fail:
35882 return NULL;
35883 }
35884
35885
35886 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35887 PyObject *resultobj;
35888 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35889 bool result;
35890 PyObject * obj0 = 0 ;
35891 char *kwnames[] = {
35892 (char *) "self", NULL
35893 };
35894
35895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35897 if (SWIG_arg_fail(1)) SWIG_fail;
35898 {
35899 PyThreadState* __tstate = wxPyBeginAllowThreads();
35900 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35901
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 {
35906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35907 }
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35915 PyObject *resultobj;
35916 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35917 wxFrame *arg2 = (wxFrame *) 0 ;
35918 PyObject * obj0 = 0 ;
35919 PyObject * obj1 = 0 ;
35920 char *kwnames[] = {
35921 (char *) "self",(char *) "frame", NULL
35922 };
35923
35924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35926 if (SWIG_arg_fail(1)) SWIG_fail;
35927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35928 if (SWIG_arg_fail(2)) SWIG_fail;
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 (arg1)->Attach(arg2);
35932
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 Py_INCREF(Py_None); resultobj = Py_None;
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj;
35945 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35946 PyObject * obj0 = 0 ;
35947 char *kwnames[] = {
35948 (char *) "self", NULL
35949 };
35950
35951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35953 if (SWIG_arg_fail(1)) SWIG_fail;
35954 {
35955 PyThreadState* __tstate = wxPyBeginAllowThreads();
35956 (arg1)->Detach();
35957
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 Py_INCREF(Py_None); resultobj = Py_None;
35962 return resultobj;
35963 fail:
35964 return NULL;
35965 }
35966
35967
35968 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35969 PyObject *obj;
35970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35971 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35972 Py_INCREF(obj);
35973 return Py_BuildValue((char *)"");
35974 }
35975 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35976 PyObject *resultobj;
35977 wxMenu *arg1 = (wxMenu *) NULL ;
35978 int arg2 = (int) wxID_ANY ;
35979 wxString const &arg3_defvalue = wxPyEmptyString ;
35980 wxString *arg3 = (wxString *) &arg3_defvalue ;
35981 wxString const &arg4_defvalue = wxPyEmptyString ;
35982 wxString *arg4 = (wxString *) &arg4_defvalue ;
35983 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35984 wxMenu *arg6 = (wxMenu *) NULL ;
35985 wxMenuItem *result;
35986 bool temp3 = false ;
35987 bool temp4 = false ;
35988 PyObject * obj0 = 0 ;
35989 PyObject * obj1 = 0 ;
35990 PyObject * obj2 = 0 ;
35991 PyObject * obj3 = 0 ;
35992 PyObject * obj4 = 0 ;
35993 PyObject * obj5 = 0 ;
35994 char *kwnames[] = {
35995 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35996 };
35997
35998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35999 if (obj0) {
36000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36001 if (SWIG_arg_fail(1)) SWIG_fail;
36002 }
36003 if (obj1) {
36004 {
36005 arg2 = (int)(SWIG_As_int(obj1));
36006 if (SWIG_arg_fail(2)) SWIG_fail;
36007 }
36008 }
36009 if (obj2) {
36010 {
36011 arg3 = wxString_in_helper(obj2);
36012 if (arg3 == NULL) SWIG_fail;
36013 temp3 = true;
36014 }
36015 }
36016 if (obj3) {
36017 {
36018 arg4 = wxString_in_helper(obj3);
36019 if (arg4 == NULL) SWIG_fail;
36020 temp4 = true;
36021 }
36022 }
36023 if (obj4) {
36024 {
36025 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36026 if (SWIG_arg_fail(5)) SWIG_fail;
36027 }
36028 }
36029 if (obj5) {
36030 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36031 if (SWIG_arg_fail(6)) SWIG_fail;
36032 }
36033 {
36034 PyThreadState* __tstate = wxPyBeginAllowThreads();
36035 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36036
36037 wxPyEndAllowThreads(__tstate);
36038 if (PyErr_Occurred()) SWIG_fail;
36039 }
36040 {
36041 resultobj = wxPyMake_wxObject(result, 1);
36042 }
36043 {
36044 if (temp3)
36045 delete arg3;
36046 }
36047 {
36048 if (temp4)
36049 delete arg4;
36050 }
36051 return resultobj;
36052 fail:
36053 {
36054 if (temp3)
36055 delete arg3;
36056 }
36057 {
36058 if (temp4)
36059 delete arg4;
36060 }
36061 return NULL;
36062 }
36063
36064
36065 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36066 PyObject *resultobj;
36067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36068 wxMenu *result;
36069 PyObject * obj0 = 0 ;
36070 char *kwnames[] = {
36071 (char *) "self", NULL
36072 };
36073
36074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36076 if (SWIG_arg_fail(1)) SWIG_fail;
36077 {
36078 PyThreadState* __tstate = wxPyBeginAllowThreads();
36079 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36080
36081 wxPyEndAllowThreads(__tstate);
36082 if (PyErr_Occurred()) SWIG_fail;
36083 }
36084 {
36085 resultobj = wxPyMake_wxObject(result, 0);
36086 }
36087 return resultobj;
36088 fail:
36089 return NULL;
36090 }
36091
36092
36093 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36094 PyObject *resultobj;
36095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36096 wxMenu *arg2 = (wxMenu *) 0 ;
36097 PyObject * obj0 = 0 ;
36098 PyObject * obj1 = 0 ;
36099 char *kwnames[] = {
36100 (char *) "self",(char *) "menu", NULL
36101 };
36102
36103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36105 if (SWIG_arg_fail(1)) SWIG_fail;
36106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36107 if (SWIG_arg_fail(2)) SWIG_fail;
36108 {
36109 PyThreadState* __tstate = wxPyBeginAllowThreads();
36110 (arg1)->SetMenu(arg2);
36111
36112 wxPyEndAllowThreads(__tstate);
36113 if (PyErr_Occurred()) SWIG_fail;
36114 }
36115 Py_INCREF(Py_None); resultobj = Py_None;
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj;
36124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36125 int arg2 ;
36126 PyObject * obj0 = 0 ;
36127 PyObject * obj1 = 0 ;
36128 char *kwnames[] = {
36129 (char *) "self",(char *) "id", NULL
36130 };
36131
36132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36134 if (SWIG_arg_fail(1)) SWIG_fail;
36135 {
36136 arg2 = (int)(SWIG_As_int(obj1));
36137 if (SWIG_arg_fail(2)) SWIG_fail;
36138 }
36139 {
36140 PyThreadState* __tstate = wxPyBeginAllowThreads();
36141 (arg1)->SetId(arg2);
36142
36143 wxPyEndAllowThreads(__tstate);
36144 if (PyErr_Occurred()) SWIG_fail;
36145 }
36146 Py_INCREF(Py_None); resultobj = Py_None;
36147 return resultobj;
36148 fail:
36149 return NULL;
36150 }
36151
36152
36153 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36154 PyObject *resultobj;
36155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36156 int result;
36157 PyObject * obj0 = 0 ;
36158 char *kwnames[] = {
36159 (char *) "self", NULL
36160 };
36161
36162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36164 if (SWIG_arg_fail(1)) SWIG_fail;
36165 {
36166 PyThreadState* __tstate = wxPyBeginAllowThreads();
36167 result = (int)((wxMenuItem const *)arg1)->GetId();
36168
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 {
36173 resultobj = SWIG_From_int((int)(result));
36174 }
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36182 PyObject *resultobj;
36183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36184 bool result;
36185 PyObject * obj0 = 0 ;
36186 char *kwnames[] = {
36187 (char *) "self", NULL
36188 };
36189
36190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36192 if (SWIG_arg_fail(1)) SWIG_fail;
36193 {
36194 PyThreadState* __tstate = wxPyBeginAllowThreads();
36195 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36196
36197 wxPyEndAllowThreads(__tstate);
36198 if (PyErr_Occurred()) SWIG_fail;
36199 }
36200 {
36201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36202 }
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj;
36211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36212 wxString *arg2 = 0 ;
36213 bool temp2 = false ;
36214 PyObject * obj0 = 0 ;
36215 PyObject * obj1 = 0 ;
36216 char *kwnames[] = {
36217 (char *) "self",(char *) "str", NULL
36218 };
36219
36220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36222 if (SWIG_arg_fail(1)) SWIG_fail;
36223 {
36224 arg2 = wxString_in_helper(obj1);
36225 if (arg2 == NULL) SWIG_fail;
36226 temp2 = true;
36227 }
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 (arg1)->SetText((wxString const &)*arg2);
36231
36232 wxPyEndAllowThreads(__tstate);
36233 if (PyErr_Occurred()) SWIG_fail;
36234 }
36235 Py_INCREF(Py_None); resultobj = Py_None;
36236 {
36237 if (temp2)
36238 delete arg2;
36239 }
36240 return resultobj;
36241 fail:
36242 {
36243 if (temp2)
36244 delete arg2;
36245 }
36246 return NULL;
36247 }
36248
36249
36250 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj;
36252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36253 wxString result;
36254 PyObject * obj0 = 0 ;
36255 char *kwnames[] = {
36256 (char *) "self", NULL
36257 };
36258
36259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(1)) SWIG_fail;
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 result = ((wxMenuItem const *)arg1)->GetLabel();
36265
36266 wxPyEndAllowThreads(__tstate);
36267 if (PyErr_Occurred()) SWIG_fail;
36268 }
36269 {
36270 #if wxUSE_UNICODE
36271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36272 #else
36273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36274 #endif
36275 }
36276 return resultobj;
36277 fail:
36278 return NULL;
36279 }
36280
36281
36282 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36283 PyObject *resultobj;
36284 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36285 wxString *result;
36286 PyObject * obj0 = 0 ;
36287 char *kwnames[] = {
36288 (char *) "self", NULL
36289 };
36290
36291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36293 if (SWIG_arg_fail(1)) SWIG_fail;
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 {
36297 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36298 result = (wxString *) &_result_ref;
36299 }
36300
36301 wxPyEndAllowThreads(__tstate);
36302 if (PyErr_Occurred()) SWIG_fail;
36303 }
36304 {
36305 #if wxUSE_UNICODE
36306 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36307 #else
36308 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36309 #endif
36310 }
36311 return resultobj;
36312 fail:
36313 return NULL;
36314 }
36315
36316
36317 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36318 PyObject *resultobj;
36319 wxString *arg1 = 0 ;
36320 wxString result;
36321 bool temp1 = false ;
36322 PyObject * obj0 = 0 ;
36323 char *kwnames[] = {
36324 (char *) "text", NULL
36325 };
36326
36327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36328 {
36329 arg1 = wxString_in_helper(obj0);
36330 if (arg1 == NULL) SWIG_fail;
36331 temp1 = true;
36332 }
36333 {
36334 PyThreadState* __tstate = wxPyBeginAllowThreads();
36335 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36336
36337 wxPyEndAllowThreads(__tstate);
36338 if (PyErr_Occurred()) SWIG_fail;
36339 }
36340 {
36341 #if wxUSE_UNICODE
36342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36343 #else
36344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36345 #endif
36346 }
36347 {
36348 if (temp1)
36349 delete arg1;
36350 }
36351 return resultobj;
36352 fail:
36353 {
36354 if (temp1)
36355 delete arg1;
36356 }
36357 return NULL;
36358 }
36359
36360
36361 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36362 PyObject *resultobj;
36363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36364 wxItemKind result;
36365 PyObject * obj0 = 0 ;
36366 char *kwnames[] = {
36367 (char *) "self", NULL
36368 };
36369
36370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36372 if (SWIG_arg_fail(1)) SWIG_fail;
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36376
36377 wxPyEndAllowThreads(__tstate);
36378 if (PyErr_Occurred()) SWIG_fail;
36379 }
36380 resultobj = SWIG_From_int((result));
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36388 PyObject *resultobj;
36389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36390 wxItemKind arg2 ;
36391 PyObject * obj0 = 0 ;
36392 PyObject * obj1 = 0 ;
36393 char *kwnames[] = {
36394 (char *) "self",(char *) "kind", NULL
36395 };
36396
36397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36399 if (SWIG_arg_fail(1)) SWIG_fail;
36400 {
36401 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36402 if (SWIG_arg_fail(2)) SWIG_fail;
36403 }
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 (arg1)->SetKind((wxItemKind )arg2);
36407
36408 wxPyEndAllowThreads(__tstate);
36409 if (PyErr_Occurred()) SWIG_fail;
36410 }
36411 Py_INCREF(Py_None); resultobj = Py_None;
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj;
36420 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36421 bool arg2 ;
36422 PyObject * obj0 = 0 ;
36423 PyObject * obj1 = 0 ;
36424 char *kwnames[] = {
36425 (char *) "self",(char *) "checkable", NULL
36426 };
36427
36428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36430 if (SWIG_arg_fail(1)) SWIG_fail;
36431 {
36432 arg2 = (bool)(SWIG_As_bool(obj1));
36433 if (SWIG_arg_fail(2)) SWIG_fail;
36434 }
36435 {
36436 PyThreadState* __tstate = wxPyBeginAllowThreads();
36437 (arg1)->SetCheckable(arg2);
36438
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 Py_INCREF(Py_None); resultobj = Py_None;
36443 return resultobj;
36444 fail:
36445 return NULL;
36446 }
36447
36448
36449 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36450 PyObject *resultobj;
36451 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36452 bool result;
36453 PyObject * obj0 = 0 ;
36454 char *kwnames[] = {
36455 (char *) "self", NULL
36456 };
36457
36458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36460 if (SWIG_arg_fail(1)) SWIG_fail;
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36464
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 {
36469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36470 }
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36478 PyObject *resultobj;
36479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36480 bool result;
36481 PyObject * obj0 = 0 ;
36482 char *kwnames[] = {
36483 (char *) "self", NULL
36484 };
36485
36486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36488 if (SWIG_arg_fail(1)) SWIG_fail;
36489 {
36490 PyThreadState* __tstate = wxPyBeginAllowThreads();
36491 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36492
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 {
36497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36498 }
36499 return resultobj;
36500 fail:
36501 return NULL;
36502 }
36503
36504
36505 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36506 PyObject *resultobj;
36507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36508 wxMenu *arg2 = (wxMenu *) 0 ;
36509 PyObject * obj0 = 0 ;
36510 PyObject * obj1 = 0 ;
36511 char *kwnames[] = {
36512 (char *) "self",(char *) "menu", NULL
36513 };
36514
36515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36517 if (SWIG_arg_fail(1)) SWIG_fail;
36518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36519 if (SWIG_arg_fail(2)) SWIG_fail;
36520 {
36521 PyThreadState* __tstate = wxPyBeginAllowThreads();
36522 (arg1)->SetSubMenu(arg2);
36523
36524 wxPyEndAllowThreads(__tstate);
36525 if (PyErr_Occurred()) SWIG_fail;
36526 }
36527 Py_INCREF(Py_None); resultobj = Py_None;
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj;
36536 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36537 wxMenu *result;
36538 PyObject * obj0 = 0 ;
36539 char *kwnames[] = {
36540 (char *) "self", NULL
36541 };
36542
36543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36545 if (SWIG_arg_fail(1)) SWIG_fail;
36546 {
36547 PyThreadState* __tstate = wxPyBeginAllowThreads();
36548 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36549
36550 wxPyEndAllowThreads(__tstate);
36551 if (PyErr_Occurred()) SWIG_fail;
36552 }
36553 {
36554 resultobj = wxPyMake_wxObject(result, 0);
36555 }
36556 return resultobj;
36557 fail:
36558 return NULL;
36559 }
36560
36561
36562 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36563 PyObject *resultobj;
36564 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36565 bool arg2 = (bool) true ;
36566 PyObject * obj0 = 0 ;
36567 PyObject * obj1 = 0 ;
36568 char *kwnames[] = {
36569 (char *) "self",(char *) "enable", NULL
36570 };
36571
36572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36574 if (SWIG_arg_fail(1)) SWIG_fail;
36575 if (obj1) {
36576 {
36577 arg2 = (bool)(SWIG_As_bool(obj1));
36578 if (SWIG_arg_fail(2)) SWIG_fail;
36579 }
36580 }
36581 {
36582 PyThreadState* __tstate = wxPyBeginAllowThreads();
36583 (arg1)->Enable(arg2);
36584
36585 wxPyEndAllowThreads(__tstate);
36586 if (PyErr_Occurred()) SWIG_fail;
36587 }
36588 Py_INCREF(Py_None); resultobj = Py_None;
36589 return resultobj;
36590 fail:
36591 return NULL;
36592 }
36593
36594
36595 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36596 PyObject *resultobj;
36597 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36598 bool result;
36599 PyObject * obj0 = 0 ;
36600 char *kwnames[] = {
36601 (char *) "self", NULL
36602 };
36603
36604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36606 if (SWIG_arg_fail(1)) SWIG_fail;
36607 {
36608 PyThreadState* __tstate = wxPyBeginAllowThreads();
36609 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36610
36611 wxPyEndAllowThreads(__tstate);
36612 if (PyErr_Occurred()) SWIG_fail;
36613 }
36614 {
36615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36616 }
36617 return resultobj;
36618 fail:
36619 return NULL;
36620 }
36621
36622
36623 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36624 PyObject *resultobj;
36625 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36626 bool arg2 = (bool) true ;
36627 PyObject * obj0 = 0 ;
36628 PyObject * obj1 = 0 ;
36629 char *kwnames[] = {
36630 (char *) "self",(char *) "check", NULL
36631 };
36632
36633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36635 if (SWIG_arg_fail(1)) SWIG_fail;
36636 if (obj1) {
36637 {
36638 arg2 = (bool)(SWIG_As_bool(obj1));
36639 if (SWIG_arg_fail(2)) SWIG_fail;
36640 }
36641 }
36642 {
36643 PyThreadState* __tstate = wxPyBeginAllowThreads();
36644 (arg1)->Check(arg2);
36645
36646 wxPyEndAllowThreads(__tstate);
36647 if (PyErr_Occurred()) SWIG_fail;
36648 }
36649 Py_INCREF(Py_None); resultobj = Py_None;
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36657 PyObject *resultobj;
36658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36659 bool result;
36660 PyObject * obj0 = 0 ;
36661 char *kwnames[] = {
36662 (char *) "self", NULL
36663 };
36664
36665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36667 if (SWIG_arg_fail(1)) SWIG_fail;
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36671
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 {
36676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36677 }
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36685 PyObject *resultobj;
36686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36687 PyObject * obj0 = 0 ;
36688 char *kwnames[] = {
36689 (char *) "self", NULL
36690 };
36691
36692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36694 if (SWIG_arg_fail(1)) SWIG_fail;
36695 {
36696 PyThreadState* __tstate = wxPyBeginAllowThreads();
36697 (arg1)->Toggle();
36698
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 Py_INCREF(Py_None); resultobj = Py_None;
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36710 PyObject *resultobj;
36711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36712 wxString *arg2 = 0 ;
36713 bool temp2 = false ;
36714 PyObject * obj0 = 0 ;
36715 PyObject * obj1 = 0 ;
36716 char *kwnames[] = {
36717 (char *) "self",(char *) "str", NULL
36718 };
36719
36720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36722 if (SWIG_arg_fail(1)) SWIG_fail;
36723 {
36724 arg2 = wxString_in_helper(obj1);
36725 if (arg2 == NULL) SWIG_fail;
36726 temp2 = true;
36727 }
36728 {
36729 PyThreadState* __tstate = wxPyBeginAllowThreads();
36730 (arg1)->SetHelp((wxString const &)*arg2);
36731
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 Py_INCREF(Py_None); resultobj = Py_None;
36736 {
36737 if (temp2)
36738 delete arg2;
36739 }
36740 return resultobj;
36741 fail:
36742 {
36743 if (temp2)
36744 delete arg2;
36745 }
36746 return NULL;
36747 }
36748
36749
36750 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36751 PyObject *resultobj;
36752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36753 wxString *result;
36754 PyObject * obj0 = 0 ;
36755 char *kwnames[] = {
36756 (char *) "self", NULL
36757 };
36758
36759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36761 if (SWIG_arg_fail(1)) SWIG_fail;
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 {
36765 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36766 result = (wxString *) &_result_ref;
36767 }
36768
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 {
36773 #if wxUSE_UNICODE
36774 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36775 #else
36776 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36777 #endif
36778 }
36779 return resultobj;
36780 fail:
36781 return NULL;
36782 }
36783
36784
36785 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36786 PyObject *resultobj;
36787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36788 wxAcceleratorEntry *result;
36789 PyObject * obj0 = 0 ;
36790 char *kwnames[] = {
36791 (char *) "self", NULL
36792 };
36793
36794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36796 if (SWIG_arg_fail(1)) SWIG_fail;
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36800
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36812 PyObject *resultobj;
36813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36814 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36815 PyObject * obj0 = 0 ;
36816 PyObject * obj1 = 0 ;
36817 char *kwnames[] = {
36818 (char *) "self",(char *) "accel", NULL
36819 };
36820
36821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(1)) SWIG_fail;
36824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36825 if (SWIG_arg_fail(2)) SWIG_fail;
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 (arg1)->SetAccel(arg2);
36829
36830 wxPyEndAllowThreads(__tstate);
36831 if (PyErr_Occurred()) SWIG_fail;
36832 }
36833 Py_INCREF(Py_None); resultobj = Py_None;
36834 return resultobj;
36835 fail:
36836 return NULL;
36837 }
36838
36839
36840 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36841 PyObject *resultobj;
36842 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36843 wxFont *arg2 = 0 ;
36844 PyObject * obj0 = 0 ;
36845 PyObject * obj1 = 0 ;
36846 char *kwnames[] = {
36847 (char *) "self",(char *) "font", NULL
36848 };
36849
36850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36852 if (SWIG_arg_fail(1)) SWIG_fail;
36853 {
36854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36855 if (SWIG_arg_fail(2)) SWIG_fail;
36856 if (arg2 == NULL) {
36857 SWIG_null_ref("wxFont");
36858 }
36859 if (SWIG_arg_fail(2)) SWIG_fail;
36860 }
36861 {
36862 PyThreadState* __tstate = wxPyBeginAllowThreads();
36863 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36864
36865 wxPyEndAllowThreads(__tstate);
36866 if (PyErr_Occurred()) SWIG_fail;
36867 }
36868 Py_INCREF(Py_None); resultobj = Py_None;
36869 return resultobj;
36870 fail:
36871 return NULL;
36872 }
36873
36874
36875 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36876 PyObject *resultobj;
36877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36878 wxFont result;
36879 PyObject * obj0 = 0 ;
36880 char *kwnames[] = {
36881 (char *) "self", NULL
36882 };
36883
36884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36886 if (SWIG_arg_fail(1)) SWIG_fail;
36887 {
36888 PyThreadState* __tstate = wxPyBeginAllowThreads();
36889 result = wxMenuItem_GetFont(arg1);
36890
36891 wxPyEndAllowThreads(__tstate);
36892 if (PyErr_Occurred()) SWIG_fail;
36893 }
36894 {
36895 wxFont * resultptr;
36896 resultptr = new wxFont((wxFont &)(result));
36897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36898 }
36899 return resultobj;
36900 fail:
36901 return NULL;
36902 }
36903
36904
36905 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36906 PyObject *resultobj;
36907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36908 wxColour *arg2 = 0 ;
36909 wxColour temp2 ;
36910 PyObject * obj0 = 0 ;
36911 PyObject * obj1 = 0 ;
36912 char *kwnames[] = {
36913 (char *) "self",(char *) "colText", NULL
36914 };
36915
36916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36918 if (SWIG_arg_fail(1)) SWIG_fail;
36919 {
36920 arg2 = &temp2;
36921 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36922 }
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36926
36927 wxPyEndAllowThreads(__tstate);
36928 if (PyErr_Occurred()) SWIG_fail;
36929 }
36930 Py_INCREF(Py_None); resultobj = Py_None;
36931 return resultobj;
36932 fail:
36933 return NULL;
36934 }
36935
36936
36937 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36938 PyObject *resultobj;
36939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36940 wxColour result;
36941 PyObject * obj0 = 0 ;
36942 char *kwnames[] = {
36943 (char *) "self", NULL
36944 };
36945
36946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36948 if (SWIG_arg_fail(1)) SWIG_fail;
36949 {
36950 PyThreadState* __tstate = wxPyBeginAllowThreads();
36951 result = wxMenuItem_GetTextColour(arg1);
36952
36953 wxPyEndAllowThreads(__tstate);
36954 if (PyErr_Occurred()) SWIG_fail;
36955 }
36956 {
36957 wxColour * resultptr;
36958 resultptr = new wxColour((wxColour &)(result));
36959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36960 }
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj;
36969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36970 wxColour *arg2 = 0 ;
36971 wxColour temp2 ;
36972 PyObject * obj0 = 0 ;
36973 PyObject * obj1 = 0 ;
36974 char *kwnames[] = {
36975 (char *) "self",(char *) "colBack", NULL
36976 };
36977
36978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36980 if (SWIG_arg_fail(1)) SWIG_fail;
36981 {
36982 arg2 = &temp2;
36983 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36984 }
36985 {
36986 PyThreadState* __tstate = wxPyBeginAllowThreads();
36987 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36988
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 Py_INCREF(Py_None); resultobj = Py_None;
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37000 PyObject *resultobj;
37001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37002 wxColour result;
37003 PyObject * obj0 = 0 ;
37004 char *kwnames[] = {
37005 (char *) "self", NULL
37006 };
37007
37008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37010 if (SWIG_arg_fail(1)) SWIG_fail;
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = wxMenuItem_GetBackgroundColour(arg1);
37014
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 {
37019 wxColour * resultptr;
37020 resultptr = new wxColour((wxColour &)(result));
37021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37022 }
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37030 PyObject *resultobj;
37031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37032 wxBitmap *arg2 = 0 ;
37033 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37034 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37035 PyObject * obj0 = 0 ;
37036 PyObject * obj1 = 0 ;
37037 PyObject * obj2 = 0 ;
37038 char *kwnames[] = {
37039 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37040 };
37041
37042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37044 if (SWIG_arg_fail(1)) SWIG_fail;
37045 {
37046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37047 if (SWIG_arg_fail(2)) SWIG_fail;
37048 if (arg2 == NULL) {
37049 SWIG_null_ref("wxBitmap");
37050 }
37051 if (SWIG_arg_fail(2)) SWIG_fail;
37052 }
37053 if (obj2) {
37054 {
37055 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37056 if (SWIG_arg_fail(3)) SWIG_fail;
37057 if (arg3 == NULL) {
37058 SWIG_null_ref("wxBitmap");
37059 }
37060 if (SWIG_arg_fail(3)) SWIG_fail;
37061 }
37062 }
37063 {
37064 PyThreadState* __tstate = wxPyBeginAllowThreads();
37065 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37066
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 Py_INCREF(Py_None); resultobj = Py_None;
37071 return resultobj;
37072 fail:
37073 return NULL;
37074 }
37075
37076
37077 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37078 PyObject *resultobj;
37079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37080 wxBitmap *arg2 = 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char *kwnames[] = {
37084 (char *) "self",(char *) "bmpDisabled", NULL
37085 };
37086
37087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37089 if (SWIG_arg_fail(1)) SWIG_fail;
37090 {
37091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37092 if (SWIG_arg_fail(2)) SWIG_fail;
37093 if (arg2 == NULL) {
37094 SWIG_null_ref("wxBitmap");
37095 }
37096 if (SWIG_arg_fail(2)) SWIG_fail;
37097 }
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37101
37102 wxPyEndAllowThreads(__tstate);
37103 if (PyErr_Occurred()) SWIG_fail;
37104 }
37105 Py_INCREF(Py_None); resultobj = Py_None;
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37113 PyObject *resultobj;
37114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37115 wxBitmap *result;
37116 PyObject * obj0 = 0 ;
37117 char *kwnames[] = {
37118 (char *) "self", NULL
37119 };
37120
37121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37123 if (SWIG_arg_fail(1)) SWIG_fail;
37124 {
37125 PyThreadState* __tstate = wxPyBeginAllowThreads();
37126 {
37127 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37128 result = (wxBitmap *) &_result_ref;
37129 }
37130
37131 wxPyEndAllowThreads(__tstate);
37132 if (PyErr_Occurred()) SWIG_fail;
37133 }
37134 {
37135 wxBitmap* resultptr = new wxBitmap(*result);
37136 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37137 }
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37145 PyObject *resultobj;
37146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37147 int arg2 ;
37148 PyObject * obj0 = 0 ;
37149 PyObject * obj1 = 0 ;
37150 char *kwnames[] = {
37151 (char *) "self",(char *) "nWidth", NULL
37152 };
37153
37154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37156 if (SWIG_arg_fail(1)) SWIG_fail;
37157 {
37158 arg2 = (int)(SWIG_As_int(obj1));
37159 if (SWIG_arg_fail(2)) SWIG_fail;
37160 }
37161 {
37162 PyThreadState* __tstate = wxPyBeginAllowThreads();
37163 wxMenuItem_SetMarginWidth(arg1,arg2);
37164
37165 wxPyEndAllowThreads(__tstate);
37166 if (PyErr_Occurred()) SWIG_fail;
37167 }
37168 Py_INCREF(Py_None); resultobj = Py_None;
37169 return resultobj;
37170 fail:
37171 return NULL;
37172 }
37173
37174
37175 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37176 PyObject *resultobj;
37177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37178 int result;
37179 PyObject * obj0 = 0 ;
37180 char *kwnames[] = {
37181 (char *) "self", NULL
37182 };
37183
37184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37186 if (SWIG_arg_fail(1)) SWIG_fail;
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (int)wxMenuItem_GetMarginWidth(arg1);
37190
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 {
37195 resultobj = SWIG_From_int((int)(result));
37196 }
37197 return resultobj;
37198 fail:
37199 return NULL;
37200 }
37201
37202
37203 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37204 PyObject *resultobj;
37205 int result;
37206 char *kwnames[] = {
37207 NULL
37208 };
37209
37210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37211 {
37212 PyThreadState* __tstate = wxPyBeginAllowThreads();
37213 result = (int)MenuItem_GetDefaultMarginWidth();
37214
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 {
37219 resultobj = SWIG_From_int((int)(result));
37220 }
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37228 PyObject *resultobj;
37229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37230 bool result;
37231 PyObject * obj0 = 0 ;
37232 char *kwnames[] = {
37233 (char *) "self", NULL
37234 };
37235
37236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37238 if (SWIG_arg_fail(1)) SWIG_fail;
37239 {
37240 PyThreadState* __tstate = wxPyBeginAllowThreads();
37241 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37242
37243 wxPyEndAllowThreads(__tstate);
37244 if (PyErr_Occurred()) SWIG_fail;
37245 }
37246 {
37247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37248 }
37249 return resultobj;
37250 fail:
37251 return NULL;
37252 }
37253
37254
37255 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37256 PyObject *resultobj;
37257 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37258 bool arg2 = (bool) true ;
37259 PyObject * obj0 = 0 ;
37260 PyObject * obj1 = 0 ;
37261 char *kwnames[] = {
37262 (char *) "self",(char *) "ownerDrawn", NULL
37263 };
37264
37265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) 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 if (obj1) {
37269 {
37270 arg2 = (bool)(SWIG_As_bool(obj1));
37271 if (SWIG_arg_fail(2)) SWIG_fail;
37272 }
37273 }
37274 {
37275 PyThreadState* __tstate = wxPyBeginAllowThreads();
37276 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37277
37278 wxPyEndAllowThreads(__tstate);
37279 if (PyErr_Occurred()) SWIG_fail;
37280 }
37281 Py_INCREF(Py_None); resultobj = Py_None;
37282 return resultobj;
37283 fail:
37284 return NULL;
37285 }
37286
37287
37288 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37289 PyObject *resultobj;
37290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37291 PyObject * obj0 = 0 ;
37292 char *kwnames[] = {
37293 (char *) "self", NULL
37294 };
37295
37296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37298 if (SWIG_arg_fail(1)) SWIG_fail;
37299 {
37300 PyThreadState* __tstate = wxPyBeginAllowThreads();
37301 wxMenuItem_ResetOwnerDrawn(arg1);
37302
37303 wxPyEndAllowThreads(__tstate);
37304 if (PyErr_Occurred()) SWIG_fail;
37305 }
37306 Py_INCREF(Py_None); resultobj = Py_None;
37307 return resultobj;
37308 fail:
37309 return NULL;
37310 }
37311
37312
37313 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37314 PyObject *resultobj;
37315 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37316 wxBitmap *arg2 = 0 ;
37317 PyObject * obj0 = 0 ;
37318 PyObject * obj1 = 0 ;
37319 char *kwnames[] = {
37320 (char *) "self",(char *) "bitmap", NULL
37321 };
37322
37323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37325 if (SWIG_arg_fail(1)) SWIG_fail;
37326 {
37327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37328 if (SWIG_arg_fail(2)) SWIG_fail;
37329 if (arg2 == NULL) {
37330 SWIG_null_ref("wxBitmap");
37331 }
37332 if (SWIG_arg_fail(2)) SWIG_fail;
37333 }
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37337
37338 wxPyEndAllowThreads(__tstate);
37339 if (PyErr_Occurred()) SWIG_fail;
37340 }
37341 Py_INCREF(Py_None); resultobj = Py_None;
37342 return resultobj;
37343 fail:
37344 return NULL;
37345 }
37346
37347
37348 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37349 PyObject *resultobj;
37350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37351 wxBitmap *result;
37352 PyObject * obj0 = 0 ;
37353 char *kwnames[] = {
37354 (char *) "self", NULL
37355 };
37356
37357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37359 if (SWIG_arg_fail(1)) SWIG_fail;
37360 {
37361 PyThreadState* __tstate = wxPyBeginAllowThreads();
37362 {
37363 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37364 result = (wxBitmap *) &_result_ref;
37365 }
37366
37367 wxPyEndAllowThreads(__tstate);
37368 if (PyErr_Occurred()) SWIG_fail;
37369 }
37370 {
37371 wxBitmap* resultptr = new wxBitmap(*result);
37372 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37373 }
37374 return resultobj;
37375 fail:
37376 return NULL;
37377 }
37378
37379
37380 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37381 PyObject *obj;
37382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37383 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37384 Py_INCREF(obj);
37385 return Py_BuildValue((char *)"");
37386 }
37387 static int _wrap_ControlNameStr_set(PyObject *) {
37388 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37389 return 1;
37390 }
37391
37392
37393 static PyObject *_wrap_ControlNameStr_get(void) {
37394 PyObject *pyobj;
37395
37396 {
37397 #if wxUSE_UNICODE
37398 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37399 #else
37400 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37401 #endif
37402 }
37403 return pyobj;
37404 }
37405
37406
37407 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37408 PyObject *resultobj;
37409 wxWindow *arg1 = (wxWindow *) 0 ;
37410 int arg2 = (int) -1 ;
37411 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37412 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37413 wxSize const &arg4_defvalue = wxDefaultSize ;
37414 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37415 long arg5 = (long) 0 ;
37416 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37417 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37418 wxString const &arg7_defvalue = wxPyControlNameStr ;
37419 wxString *arg7 = (wxString *) &arg7_defvalue ;
37420 wxControl *result;
37421 wxPoint temp3 ;
37422 wxSize temp4 ;
37423 bool temp7 = false ;
37424 PyObject * obj0 = 0 ;
37425 PyObject * obj1 = 0 ;
37426 PyObject * obj2 = 0 ;
37427 PyObject * obj3 = 0 ;
37428 PyObject * obj4 = 0 ;
37429 PyObject * obj5 = 0 ;
37430 PyObject * obj6 = 0 ;
37431 char *kwnames[] = {
37432 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37433 };
37434
37435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37437 if (SWIG_arg_fail(1)) SWIG_fail;
37438 if (obj1) {
37439 {
37440 arg2 = (int)(SWIG_As_int(obj1));
37441 if (SWIG_arg_fail(2)) SWIG_fail;
37442 }
37443 }
37444 if (obj2) {
37445 {
37446 arg3 = &temp3;
37447 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37448 }
37449 }
37450 if (obj3) {
37451 {
37452 arg4 = &temp4;
37453 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37454 }
37455 }
37456 if (obj4) {
37457 {
37458 arg5 = (long)(SWIG_As_long(obj4));
37459 if (SWIG_arg_fail(5)) SWIG_fail;
37460 }
37461 }
37462 if (obj5) {
37463 {
37464 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37465 if (SWIG_arg_fail(6)) SWIG_fail;
37466 if (arg6 == NULL) {
37467 SWIG_null_ref("wxValidator");
37468 }
37469 if (SWIG_arg_fail(6)) SWIG_fail;
37470 }
37471 }
37472 if (obj6) {
37473 {
37474 arg7 = wxString_in_helper(obj6);
37475 if (arg7 == NULL) SWIG_fail;
37476 temp7 = true;
37477 }
37478 }
37479 {
37480 if (!wxPyCheckForApp()) SWIG_fail;
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37483
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37488 {
37489 if (temp7)
37490 delete arg7;
37491 }
37492 return resultobj;
37493 fail:
37494 {
37495 if (temp7)
37496 delete arg7;
37497 }
37498 return NULL;
37499 }
37500
37501
37502 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37503 PyObject *resultobj;
37504 wxControl *result;
37505 char *kwnames[] = {
37506 NULL
37507 };
37508
37509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37510 {
37511 if (!wxPyCheckForApp()) SWIG_fail;
37512 PyThreadState* __tstate = wxPyBeginAllowThreads();
37513 result = (wxControl *)new wxControl();
37514
37515 wxPyEndAllowThreads(__tstate);
37516 if (PyErr_Occurred()) SWIG_fail;
37517 }
37518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37519 return resultobj;
37520 fail:
37521 return NULL;
37522 }
37523
37524
37525 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37526 PyObject *resultobj;
37527 wxControl *arg1 = (wxControl *) 0 ;
37528 wxWindow *arg2 = (wxWindow *) 0 ;
37529 int arg3 = (int) -1 ;
37530 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37531 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37532 wxSize const &arg5_defvalue = wxDefaultSize ;
37533 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37534 long arg6 = (long) 0 ;
37535 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37536 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37537 wxString const &arg8_defvalue = wxPyControlNameStr ;
37538 wxString *arg8 = (wxString *) &arg8_defvalue ;
37539 bool result;
37540 wxPoint temp4 ;
37541 wxSize temp5 ;
37542 bool temp8 = false ;
37543 PyObject * obj0 = 0 ;
37544 PyObject * obj1 = 0 ;
37545 PyObject * obj2 = 0 ;
37546 PyObject * obj3 = 0 ;
37547 PyObject * obj4 = 0 ;
37548 PyObject * obj5 = 0 ;
37549 PyObject * obj6 = 0 ;
37550 PyObject * obj7 = 0 ;
37551 char *kwnames[] = {
37552 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37553 };
37554
37555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37557 if (SWIG_arg_fail(1)) SWIG_fail;
37558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37559 if (SWIG_arg_fail(2)) SWIG_fail;
37560 if (obj2) {
37561 {
37562 arg3 = (int)(SWIG_As_int(obj2));
37563 if (SWIG_arg_fail(3)) SWIG_fail;
37564 }
37565 }
37566 if (obj3) {
37567 {
37568 arg4 = &temp4;
37569 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37570 }
37571 }
37572 if (obj4) {
37573 {
37574 arg5 = &temp5;
37575 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37576 }
37577 }
37578 if (obj5) {
37579 {
37580 arg6 = (long)(SWIG_As_long(obj5));
37581 if (SWIG_arg_fail(6)) SWIG_fail;
37582 }
37583 }
37584 if (obj6) {
37585 {
37586 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37587 if (SWIG_arg_fail(7)) SWIG_fail;
37588 if (arg7 == NULL) {
37589 SWIG_null_ref("wxValidator");
37590 }
37591 if (SWIG_arg_fail(7)) SWIG_fail;
37592 }
37593 }
37594 if (obj7) {
37595 {
37596 arg8 = wxString_in_helper(obj7);
37597 if (arg8 == NULL) SWIG_fail;
37598 temp8 = true;
37599 }
37600 }
37601 {
37602 PyThreadState* __tstate = wxPyBeginAllowThreads();
37603 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37604
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 {
37609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37610 }
37611 {
37612 if (temp8)
37613 delete arg8;
37614 }
37615 return resultobj;
37616 fail:
37617 {
37618 if (temp8)
37619 delete arg8;
37620 }
37621 return NULL;
37622 }
37623
37624
37625 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37626 PyObject *resultobj;
37627 wxControl *arg1 = (wxControl *) 0 ;
37628 wxCommandEvent *arg2 = 0 ;
37629 PyObject * obj0 = 0 ;
37630 PyObject * obj1 = 0 ;
37631 char *kwnames[] = {
37632 (char *) "self",(char *) "event", NULL
37633 };
37634
37635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37637 if (SWIG_arg_fail(1)) SWIG_fail;
37638 {
37639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37640 if (SWIG_arg_fail(2)) SWIG_fail;
37641 if (arg2 == NULL) {
37642 SWIG_null_ref("wxCommandEvent");
37643 }
37644 if (SWIG_arg_fail(2)) SWIG_fail;
37645 }
37646 {
37647 PyThreadState* __tstate = wxPyBeginAllowThreads();
37648 (arg1)->Command(*arg2);
37649
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 Py_INCREF(Py_None); resultobj = Py_None;
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj;
37662 wxControl *arg1 = (wxControl *) 0 ;
37663 wxString result;
37664 PyObject * obj0 = 0 ;
37665 char *kwnames[] = {
37666 (char *) "self", NULL
37667 };
37668
37669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37671 if (SWIG_arg_fail(1)) SWIG_fail;
37672 {
37673 PyThreadState* __tstate = wxPyBeginAllowThreads();
37674 result = (arg1)->GetLabel();
37675
37676 wxPyEndAllowThreads(__tstate);
37677 if (PyErr_Occurred()) SWIG_fail;
37678 }
37679 {
37680 #if wxUSE_UNICODE
37681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37682 #else
37683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37684 #endif
37685 }
37686 return resultobj;
37687 fail:
37688 return NULL;
37689 }
37690
37691
37692 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37693 PyObject *resultobj;
37694 wxControl *arg1 = (wxControl *) 0 ;
37695 wxString *arg2 = 0 ;
37696 bool temp2 = false ;
37697 PyObject * obj0 = 0 ;
37698 PyObject * obj1 = 0 ;
37699 char *kwnames[] = {
37700 (char *) "self",(char *) "label", NULL
37701 };
37702
37703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37705 if (SWIG_arg_fail(1)) SWIG_fail;
37706 {
37707 arg2 = wxString_in_helper(obj1);
37708 if (arg2 == NULL) SWIG_fail;
37709 temp2 = true;
37710 }
37711 {
37712 PyThreadState* __tstate = wxPyBeginAllowThreads();
37713 (arg1)->SetLabel((wxString const &)*arg2);
37714
37715 wxPyEndAllowThreads(__tstate);
37716 if (PyErr_Occurred()) SWIG_fail;
37717 }
37718 Py_INCREF(Py_None); resultobj = Py_None;
37719 {
37720 if (temp2)
37721 delete arg2;
37722 }
37723 return resultobj;
37724 fail:
37725 {
37726 if (temp2)
37727 delete arg2;
37728 }
37729 return NULL;
37730 }
37731
37732
37733 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37734 PyObject *resultobj;
37735 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37736 wxVisualAttributes result;
37737 PyObject * obj0 = 0 ;
37738 char *kwnames[] = {
37739 (char *) "variant", NULL
37740 };
37741
37742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37743 if (obj0) {
37744 {
37745 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37746 if (SWIG_arg_fail(1)) SWIG_fail;
37747 }
37748 }
37749 {
37750 if (!wxPyCheckForApp()) SWIG_fail;
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37753
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 wxVisualAttributes * resultptr;
37759 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37761 }
37762 return resultobj;
37763 fail:
37764 return NULL;
37765 }
37766
37767
37768 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37769 PyObject *obj;
37770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37771 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37772 Py_INCREF(obj);
37773 return Py_BuildValue((char *)"");
37774 }
37775 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37776 PyObject *resultobj;
37777 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37778 wxString *arg2 = 0 ;
37779 PyObject *arg3 = (PyObject *) NULL ;
37780 int result;
37781 bool temp2 = false ;
37782 PyObject * obj0 = 0 ;
37783 PyObject * obj1 = 0 ;
37784 PyObject * obj2 = 0 ;
37785 char *kwnames[] = {
37786 (char *) "self",(char *) "item",(char *) "clientData", NULL
37787 };
37788
37789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37791 if (SWIG_arg_fail(1)) SWIG_fail;
37792 {
37793 arg2 = wxString_in_helper(obj1);
37794 if (arg2 == NULL) SWIG_fail;
37795 temp2 = true;
37796 }
37797 if (obj2) {
37798 arg3 = obj2;
37799 }
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37803
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 {
37808 resultobj = SWIG_From_int((int)(result));
37809 }
37810 {
37811 if (temp2)
37812 delete arg2;
37813 }
37814 return resultobj;
37815 fail:
37816 {
37817 if (temp2)
37818 delete arg2;
37819 }
37820 return NULL;
37821 }
37822
37823
37824 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37825 PyObject *resultobj;
37826 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37827 wxArrayString *arg2 = 0 ;
37828 bool temp2 = false ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 char *kwnames[] = {
37832 (char *) "self",(char *) "strings", NULL
37833 };
37834
37835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37837 if (SWIG_arg_fail(1)) SWIG_fail;
37838 {
37839 if (! PySequence_Check(obj1)) {
37840 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37841 SWIG_fail;
37842 }
37843 arg2 = new wxArrayString;
37844 temp2 = true;
37845 int i, len=PySequence_Length(obj1);
37846 for (i=0; i<len; i++) {
37847 PyObject* item = PySequence_GetItem(obj1, i);
37848 wxString* s = wxString_in_helper(item);
37849 if (PyErr_Occurred()) SWIG_fail;
37850 arg2->Add(*s);
37851 delete s;
37852 Py_DECREF(item);
37853 }
37854 }
37855 {
37856 PyThreadState* __tstate = wxPyBeginAllowThreads();
37857 (arg1)->Append((wxArrayString const &)*arg2);
37858
37859 wxPyEndAllowThreads(__tstate);
37860 if (PyErr_Occurred()) SWIG_fail;
37861 }
37862 Py_INCREF(Py_None); resultobj = Py_None;
37863 {
37864 if (temp2) delete arg2;
37865 }
37866 return resultobj;
37867 fail:
37868 {
37869 if (temp2) delete arg2;
37870 }
37871 return NULL;
37872 }
37873
37874
37875 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37876 PyObject *resultobj;
37877 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37878 wxString *arg2 = 0 ;
37879 int arg3 ;
37880 PyObject *arg4 = (PyObject *) NULL ;
37881 int result;
37882 bool temp2 = false ;
37883 PyObject * obj0 = 0 ;
37884 PyObject * obj1 = 0 ;
37885 PyObject * obj2 = 0 ;
37886 PyObject * obj3 = 0 ;
37887 char *kwnames[] = {
37888 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37889 };
37890
37891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37893 if (SWIG_arg_fail(1)) SWIG_fail;
37894 {
37895 arg2 = wxString_in_helper(obj1);
37896 if (arg2 == NULL) SWIG_fail;
37897 temp2 = true;
37898 }
37899 {
37900 arg3 = (int)(SWIG_As_int(obj2));
37901 if (SWIG_arg_fail(3)) SWIG_fail;
37902 }
37903 if (obj3) {
37904 arg4 = obj3;
37905 }
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37909
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 {
37914 resultobj = SWIG_From_int((int)(result));
37915 }
37916 {
37917 if (temp2)
37918 delete arg2;
37919 }
37920 return resultobj;
37921 fail:
37922 {
37923 if (temp2)
37924 delete arg2;
37925 }
37926 return NULL;
37927 }
37928
37929
37930 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37931 PyObject *resultobj;
37932 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37933 PyObject * obj0 = 0 ;
37934 char *kwnames[] = {
37935 (char *) "self", NULL
37936 };
37937
37938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37940 if (SWIG_arg_fail(1)) SWIG_fail;
37941 {
37942 PyThreadState* __tstate = wxPyBeginAllowThreads();
37943 (arg1)->Clear();
37944
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 Py_INCREF(Py_None); resultobj = Py_None;
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37956 PyObject *resultobj;
37957 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37958 int arg2 ;
37959 PyObject * obj0 = 0 ;
37960 PyObject * obj1 = 0 ;
37961 char *kwnames[] = {
37962 (char *) "self",(char *) "n", NULL
37963 };
37964
37965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37967 if (SWIG_arg_fail(1)) SWIG_fail;
37968 {
37969 arg2 = (int)(SWIG_As_int(obj1));
37970 if (SWIG_arg_fail(2)) SWIG_fail;
37971 }
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 (arg1)->Delete(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_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37987 PyObject *resultobj;
37988 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37989 int arg2 ;
37990 PyObject *result;
37991 PyObject * obj0 = 0 ;
37992 PyObject * obj1 = 0 ;
37993 char *kwnames[] = {
37994 (char *) "self",(char *) "n", NULL
37995 };
37996
37997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37999 if (SWIG_arg_fail(1)) SWIG_fail;
38000 {
38001 arg2 = (int)(SWIG_As_int(obj1));
38002 if (SWIG_arg_fail(2)) SWIG_fail;
38003 }
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38007
38008 wxPyEndAllowThreads(__tstate);
38009 if (PyErr_Occurred()) SWIG_fail;
38010 }
38011 resultobj = result;
38012 return resultobj;
38013 fail:
38014 return NULL;
38015 }
38016
38017
38018 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38019 PyObject *resultobj;
38020 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38021 int arg2 ;
38022 PyObject *arg3 = (PyObject *) 0 ;
38023 PyObject * obj0 = 0 ;
38024 PyObject * obj1 = 0 ;
38025 PyObject * obj2 = 0 ;
38026 char *kwnames[] = {
38027 (char *) "self",(char *) "n",(char *) "clientData", NULL
38028 };
38029
38030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38032 if (SWIG_arg_fail(1)) SWIG_fail;
38033 {
38034 arg2 = (int)(SWIG_As_int(obj1));
38035 if (SWIG_arg_fail(2)) SWIG_fail;
38036 }
38037 arg3 = obj2;
38038 {
38039 PyThreadState* __tstate = wxPyBeginAllowThreads();
38040 wxItemContainer_SetClientData(arg1,arg2,arg3);
38041
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 Py_INCREF(Py_None); resultobj = Py_None;
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38053 PyObject *resultobj;
38054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38055 int result;
38056 PyObject * obj0 = 0 ;
38057 char *kwnames[] = {
38058 (char *) "self", NULL
38059 };
38060
38061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38063 if (SWIG_arg_fail(1)) SWIG_fail;
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 result = (int)((wxItemContainer const *)arg1)->GetCount();
38067
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 {
38072 resultobj = SWIG_From_int((int)(result));
38073 }
38074 return resultobj;
38075 fail:
38076 return NULL;
38077 }
38078
38079
38080 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38081 PyObject *resultobj;
38082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38083 bool result;
38084 PyObject * obj0 = 0 ;
38085 char *kwnames[] = {
38086 (char *) "self", NULL
38087 };
38088
38089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38091 if (SWIG_arg_fail(1)) SWIG_fail;
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38095
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 {
38100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38101 }
38102 return resultobj;
38103 fail:
38104 return NULL;
38105 }
38106
38107
38108 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38109 PyObject *resultobj;
38110 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38111 int arg2 ;
38112 wxString result;
38113 PyObject * obj0 = 0 ;
38114 PyObject * obj1 = 0 ;
38115 char *kwnames[] = {
38116 (char *) "self",(char *) "n", NULL
38117 };
38118
38119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38121 if (SWIG_arg_fail(1)) SWIG_fail;
38122 {
38123 arg2 = (int)(SWIG_As_int(obj1));
38124 if (SWIG_arg_fail(2)) SWIG_fail;
38125 }
38126 {
38127 PyThreadState* __tstate = wxPyBeginAllowThreads();
38128 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38129
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 {
38134 #if wxUSE_UNICODE
38135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38136 #else
38137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38138 #endif
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj;
38148 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38149 wxArrayString result;
38150 PyObject * obj0 = 0 ;
38151 char *kwnames[] = {
38152 (char *) "self", NULL
38153 };
38154
38155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38157 if (SWIG_arg_fail(1)) SWIG_fail;
38158 {
38159 PyThreadState* __tstate = wxPyBeginAllowThreads();
38160 result = ((wxItemContainer const *)arg1)->GetStrings();
38161
38162 wxPyEndAllowThreads(__tstate);
38163 if (PyErr_Occurred()) SWIG_fail;
38164 }
38165 {
38166 resultobj = wxArrayString2PyList_helper(result);
38167 }
38168 return resultobj;
38169 fail:
38170 return NULL;
38171 }
38172
38173
38174 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38175 PyObject *resultobj;
38176 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38177 int arg2 ;
38178 wxString *arg3 = 0 ;
38179 bool temp3 = false ;
38180 PyObject * obj0 = 0 ;
38181 PyObject * obj1 = 0 ;
38182 PyObject * obj2 = 0 ;
38183 char *kwnames[] = {
38184 (char *) "self",(char *) "n",(char *) "s", NULL
38185 };
38186
38187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38189 if (SWIG_arg_fail(1)) SWIG_fail;
38190 {
38191 arg2 = (int)(SWIG_As_int(obj1));
38192 if (SWIG_arg_fail(2)) SWIG_fail;
38193 }
38194 {
38195 arg3 = wxString_in_helper(obj2);
38196 if (arg3 == NULL) SWIG_fail;
38197 temp3 = true;
38198 }
38199 {
38200 PyThreadState* __tstate = wxPyBeginAllowThreads();
38201 (arg1)->SetString(arg2,(wxString const &)*arg3);
38202
38203 wxPyEndAllowThreads(__tstate);
38204 if (PyErr_Occurred()) SWIG_fail;
38205 }
38206 Py_INCREF(Py_None); resultobj = Py_None;
38207 {
38208 if (temp3)
38209 delete arg3;
38210 }
38211 return resultobj;
38212 fail:
38213 {
38214 if (temp3)
38215 delete arg3;
38216 }
38217 return NULL;
38218 }
38219
38220
38221 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38222 PyObject *resultobj;
38223 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38224 wxString *arg2 = 0 ;
38225 int result;
38226 bool temp2 = false ;
38227 PyObject * obj0 = 0 ;
38228 PyObject * obj1 = 0 ;
38229 char *kwnames[] = {
38230 (char *) "self",(char *) "s", NULL
38231 };
38232
38233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38235 if (SWIG_arg_fail(1)) SWIG_fail;
38236 {
38237 arg2 = wxString_in_helper(obj1);
38238 if (arg2 == NULL) SWIG_fail;
38239 temp2 = true;
38240 }
38241 {
38242 PyThreadState* __tstate = wxPyBeginAllowThreads();
38243 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38244
38245 wxPyEndAllowThreads(__tstate);
38246 if (PyErr_Occurred()) SWIG_fail;
38247 }
38248 {
38249 resultobj = SWIG_From_int((int)(result));
38250 }
38251 {
38252 if (temp2)
38253 delete arg2;
38254 }
38255 return resultobj;
38256 fail:
38257 {
38258 if (temp2)
38259 delete arg2;
38260 }
38261 return NULL;
38262 }
38263
38264
38265 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38266 PyObject *resultobj;
38267 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38268 int arg2 ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 char *kwnames[] = {
38272 (char *) "self",(char *) "n", NULL
38273 };
38274
38275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38277 if (SWIG_arg_fail(1)) SWIG_fail;
38278 {
38279 arg2 = (int)(SWIG_As_int(obj1));
38280 if (SWIG_arg_fail(2)) SWIG_fail;
38281 }
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 (arg1)->SetSelection(arg2);
38285
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 Py_INCREF(Py_None); resultobj = Py_None;
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38297 PyObject *resultobj;
38298 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38299 int result;
38300 PyObject * obj0 = 0 ;
38301 char *kwnames[] = {
38302 (char *) "self", NULL
38303 };
38304
38305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38307 if (SWIG_arg_fail(1)) SWIG_fail;
38308 {
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38311
38312 wxPyEndAllowThreads(__tstate);
38313 if (PyErr_Occurred()) SWIG_fail;
38314 }
38315 {
38316 resultobj = SWIG_From_int((int)(result));
38317 }
38318 return resultobj;
38319 fail:
38320 return NULL;
38321 }
38322
38323
38324 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38325 PyObject *resultobj;
38326 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38327 wxString *arg2 = 0 ;
38328 bool result;
38329 bool temp2 = false ;
38330 PyObject * obj0 = 0 ;
38331 PyObject * obj1 = 0 ;
38332 char *kwnames[] = {
38333 (char *) "self",(char *) "s", NULL
38334 };
38335
38336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38338 if (SWIG_arg_fail(1)) SWIG_fail;
38339 {
38340 arg2 = wxString_in_helper(obj1);
38341 if (arg2 == NULL) SWIG_fail;
38342 temp2 = true;
38343 }
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38347
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 {
38352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38353 }
38354 {
38355 if (temp2)
38356 delete arg2;
38357 }
38358 return resultobj;
38359 fail:
38360 {
38361 if (temp2)
38362 delete arg2;
38363 }
38364 return NULL;
38365 }
38366
38367
38368 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38369 PyObject *resultobj;
38370 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38371 wxString result;
38372 PyObject * obj0 = 0 ;
38373 char *kwnames[] = {
38374 (char *) "self", NULL
38375 };
38376
38377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38379 if (SWIG_arg_fail(1)) SWIG_fail;
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38383
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 {
38388 #if wxUSE_UNICODE
38389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38390 #else
38391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38392 #endif
38393 }
38394 return resultobj;
38395 fail:
38396 return NULL;
38397 }
38398
38399
38400 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38401 PyObject *resultobj;
38402 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38403 int arg2 ;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 char *kwnames[] = {
38407 (char *) "self",(char *) "n", NULL
38408 };
38409
38410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38412 if (SWIG_arg_fail(1)) SWIG_fail;
38413 {
38414 arg2 = (int)(SWIG_As_int(obj1));
38415 if (SWIG_arg_fail(2)) SWIG_fail;
38416 }
38417 {
38418 PyThreadState* __tstate = wxPyBeginAllowThreads();
38419 (arg1)->Select(arg2);
38420
38421 wxPyEndAllowThreads(__tstate);
38422 if (PyErr_Occurred()) SWIG_fail;
38423 }
38424 Py_INCREF(Py_None); resultobj = Py_None;
38425 return resultobj;
38426 fail:
38427 return NULL;
38428 }
38429
38430
38431 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38432 PyObject *obj;
38433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38434 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38435 Py_INCREF(obj);
38436 return Py_BuildValue((char *)"");
38437 }
38438 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38439 PyObject *obj;
38440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38441 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38442 Py_INCREF(obj);
38443 return Py_BuildValue((char *)"");
38444 }
38445 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38446 PyObject *resultobj;
38447 wxSizerItem *result;
38448 char *kwnames[] = {
38449 NULL
38450 };
38451
38452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38453 {
38454 PyThreadState* __tstate = wxPyBeginAllowThreads();
38455 result = (wxSizerItem *)new wxSizerItem();
38456
38457 wxPyEndAllowThreads(__tstate);
38458 if (PyErr_Occurred()) SWIG_fail;
38459 }
38460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38468 PyObject *resultobj;
38469 wxWindow *arg1 = (wxWindow *) 0 ;
38470 int arg2 ;
38471 int arg3 ;
38472 int arg4 ;
38473 PyObject *arg5 = (PyObject *) NULL ;
38474 wxSizerItem *result;
38475 PyObject * obj0 = 0 ;
38476 PyObject * obj1 = 0 ;
38477 PyObject * obj2 = 0 ;
38478 PyObject * obj3 = 0 ;
38479 PyObject * obj4 = 0 ;
38480 char *kwnames[] = {
38481 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38482 };
38483
38484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38486 if (SWIG_arg_fail(1)) SWIG_fail;
38487 {
38488 arg2 = (int)(SWIG_As_int(obj1));
38489 if (SWIG_arg_fail(2)) SWIG_fail;
38490 }
38491 {
38492 arg3 = (int)(SWIG_As_int(obj2));
38493 if (SWIG_arg_fail(3)) SWIG_fail;
38494 }
38495 {
38496 arg4 = (int)(SWIG_As_int(obj3));
38497 if (SWIG_arg_fail(4)) SWIG_fail;
38498 }
38499 if (obj4) {
38500 arg5 = obj4;
38501 }
38502 {
38503 PyThreadState* __tstate = wxPyBeginAllowThreads();
38504 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38505
38506 wxPyEndAllowThreads(__tstate);
38507 if (PyErr_Occurred()) SWIG_fail;
38508 }
38509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38510 return resultobj;
38511 fail:
38512 return NULL;
38513 }
38514
38515
38516 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38517 PyObject *resultobj;
38518 int arg1 ;
38519 int arg2 ;
38520 int arg3 ;
38521 int arg4 ;
38522 int arg5 ;
38523 PyObject *arg6 = (PyObject *) NULL ;
38524 wxSizerItem *result;
38525 PyObject * obj0 = 0 ;
38526 PyObject * obj1 = 0 ;
38527 PyObject * obj2 = 0 ;
38528 PyObject * obj3 = 0 ;
38529 PyObject * obj4 = 0 ;
38530 PyObject * obj5 = 0 ;
38531 char *kwnames[] = {
38532 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38533 };
38534
38535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38536 {
38537 arg1 = (int)(SWIG_As_int(obj0));
38538 if (SWIG_arg_fail(1)) SWIG_fail;
38539 }
38540 {
38541 arg2 = (int)(SWIG_As_int(obj1));
38542 if (SWIG_arg_fail(2)) SWIG_fail;
38543 }
38544 {
38545 arg3 = (int)(SWIG_As_int(obj2));
38546 if (SWIG_arg_fail(3)) SWIG_fail;
38547 }
38548 {
38549 arg4 = (int)(SWIG_As_int(obj3));
38550 if (SWIG_arg_fail(4)) SWIG_fail;
38551 }
38552 {
38553 arg5 = (int)(SWIG_As_int(obj4));
38554 if (SWIG_arg_fail(5)) SWIG_fail;
38555 }
38556 if (obj5) {
38557 arg6 = obj5;
38558 }
38559 {
38560 PyThreadState* __tstate = wxPyBeginAllowThreads();
38561 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38562
38563 wxPyEndAllowThreads(__tstate);
38564 if (PyErr_Occurred()) SWIG_fail;
38565 }
38566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38567 return resultobj;
38568 fail:
38569 return NULL;
38570 }
38571
38572
38573 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38574 PyObject *resultobj;
38575 wxSizer *arg1 = (wxSizer *) 0 ;
38576 int arg2 ;
38577 int arg3 ;
38578 int arg4 ;
38579 PyObject *arg5 = (PyObject *) NULL ;
38580 wxSizerItem *result;
38581 PyObject * obj0 = 0 ;
38582 PyObject * obj1 = 0 ;
38583 PyObject * obj2 = 0 ;
38584 PyObject * obj3 = 0 ;
38585 PyObject * obj4 = 0 ;
38586 char *kwnames[] = {
38587 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38588 };
38589
38590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38592 if (SWIG_arg_fail(1)) SWIG_fail;
38593 {
38594 arg2 = (int)(SWIG_As_int(obj1));
38595 if (SWIG_arg_fail(2)) SWIG_fail;
38596 }
38597 {
38598 arg3 = (int)(SWIG_As_int(obj2));
38599 if (SWIG_arg_fail(3)) SWIG_fail;
38600 }
38601 {
38602 arg4 = (int)(SWIG_As_int(obj3));
38603 if (SWIG_arg_fail(4)) SWIG_fail;
38604 }
38605 if (obj4) {
38606 arg5 = obj4;
38607 }
38608 {
38609 PyThreadState* __tstate = wxPyBeginAllowThreads();
38610 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38611
38612 wxPyEndAllowThreads(__tstate);
38613 if (PyErr_Occurred()) SWIG_fail;
38614 }
38615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38616 return resultobj;
38617 fail:
38618 return NULL;
38619 }
38620
38621
38622 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38623 PyObject *resultobj;
38624 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38625 PyObject * obj0 = 0 ;
38626 char *kwnames[] = {
38627 (char *) "self", NULL
38628 };
38629
38630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38632 if (SWIG_arg_fail(1)) SWIG_fail;
38633 {
38634 PyThreadState* __tstate = wxPyBeginAllowThreads();
38635 (arg1)->DeleteWindows();
38636
38637 wxPyEndAllowThreads(__tstate);
38638 if (PyErr_Occurred()) SWIG_fail;
38639 }
38640 Py_INCREF(Py_None); resultobj = Py_None;
38641 return resultobj;
38642 fail:
38643 return NULL;
38644 }
38645
38646
38647 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38648 PyObject *resultobj;
38649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38650 PyObject * obj0 = 0 ;
38651 char *kwnames[] = {
38652 (char *) "self", NULL
38653 };
38654
38655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38657 if (SWIG_arg_fail(1)) SWIG_fail;
38658 {
38659 PyThreadState* __tstate = wxPyBeginAllowThreads();
38660 (arg1)->DetachSizer();
38661
38662 wxPyEndAllowThreads(__tstate);
38663 if (PyErr_Occurred()) SWIG_fail;
38664 }
38665 Py_INCREF(Py_None); resultobj = Py_None;
38666 return resultobj;
38667 fail:
38668 return NULL;
38669 }
38670
38671
38672 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38673 PyObject *resultobj;
38674 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38675 wxSize result;
38676 PyObject * obj0 = 0 ;
38677 char *kwnames[] = {
38678 (char *) "self", NULL
38679 };
38680
38681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38683 if (SWIG_arg_fail(1)) SWIG_fail;
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 result = (arg1)->GetSize();
38687
38688 wxPyEndAllowThreads(__tstate);
38689 if (PyErr_Occurred()) SWIG_fail;
38690 }
38691 {
38692 wxSize * resultptr;
38693 resultptr = new wxSize((wxSize &)(result));
38694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38695 }
38696 return resultobj;
38697 fail:
38698 return NULL;
38699 }
38700
38701
38702 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38703 PyObject *resultobj;
38704 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38705 wxSize result;
38706 PyObject * obj0 = 0 ;
38707 char *kwnames[] = {
38708 (char *) "self", NULL
38709 };
38710
38711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38713 if (SWIG_arg_fail(1)) SWIG_fail;
38714 {
38715 PyThreadState* __tstate = wxPyBeginAllowThreads();
38716 result = (arg1)->CalcMin();
38717
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 {
38722 wxSize * resultptr;
38723 resultptr = new wxSize((wxSize &)(result));
38724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38725 }
38726 return resultobj;
38727 fail:
38728 return NULL;
38729 }
38730
38731
38732 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38733 PyObject *resultobj;
38734 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38735 wxPoint arg2 ;
38736 wxSize arg3 ;
38737 PyObject * obj0 = 0 ;
38738 PyObject * obj1 = 0 ;
38739 PyObject * obj2 = 0 ;
38740 char *kwnames[] = {
38741 (char *) "self",(char *) "pos",(char *) "size", NULL
38742 };
38743
38744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38746 if (SWIG_arg_fail(1)) SWIG_fail;
38747 {
38748 wxPoint * argp;
38749 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38750 if (SWIG_arg_fail(2)) SWIG_fail;
38751 if (argp == NULL) {
38752 SWIG_null_ref("wxPoint");
38753 }
38754 if (SWIG_arg_fail(2)) SWIG_fail;
38755 arg2 = *argp;
38756 }
38757 {
38758 wxSize * argp;
38759 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38760 if (SWIG_arg_fail(3)) SWIG_fail;
38761 if (argp == NULL) {
38762 SWIG_null_ref("wxSize");
38763 }
38764 if (SWIG_arg_fail(3)) SWIG_fail;
38765 arg3 = *argp;
38766 }
38767 {
38768 PyThreadState* __tstate = wxPyBeginAllowThreads();
38769 (arg1)->SetDimension(arg2,arg3);
38770
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 Py_INCREF(Py_None); resultobj = Py_None;
38775 return resultobj;
38776 fail:
38777 return NULL;
38778 }
38779
38780
38781 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38782 PyObject *resultobj;
38783 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38784 wxSize result;
38785 PyObject * obj0 = 0 ;
38786 char *kwnames[] = {
38787 (char *) "self", NULL
38788 };
38789
38790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38792 if (SWIG_arg_fail(1)) SWIG_fail;
38793 {
38794 PyThreadState* __tstate = wxPyBeginAllowThreads();
38795 result = (arg1)->GetMinSize();
38796
38797 wxPyEndAllowThreads(__tstate);
38798 if (PyErr_Occurred()) SWIG_fail;
38799 }
38800 {
38801 wxSize * resultptr;
38802 resultptr = new wxSize((wxSize &)(result));
38803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38804 }
38805 return resultobj;
38806 fail:
38807 return NULL;
38808 }
38809
38810
38811 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38812 PyObject *resultobj;
38813 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38814 wxSize result;
38815 PyObject * obj0 = 0 ;
38816 char *kwnames[] = {
38817 (char *) "self", NULL
38818 };
38819
38820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38822 if (SWIG_arg_fail(1)) SWIG_fail;
38823 {
38824 PyThreadState* __tstate = wxPyBeginAllowThreads();
38825 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38826
38827 wxPyEndAllowThreads(__tstate);
38828 if (PyErr_Occurred()) SWIG_fail;
38829 }
38830 {
38831 wxSize * resultptr;
38832 resultptr = new wxSize((wxSize &)(result));
38833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38834 }
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38842 PyObject *resultobj;
38843 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38844 int arg2 ;
38845 int arg3 ;
38846 PyObject * obj0 = 0 ;
38847 PyObject * obj1 = 0 ;
38848 PyObject * obj2 = 0 ;
38849 char *kwnames[] = {
38850 (char *) "self",(char *) "x",(char *) "y", NULL
38851 };
38852
38853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38855 if (SWIG_arg_fail(1)) SWIG_fail;
38856 {
38857 arg2 = (int)(SWIG_As_int(obj1));
38858 if (SWIG_arg_fail(2)) SWIG_fail;
38859 }
38860 {
38861 arg3 = (int)(SWIG_As_int(obj2));
38862 if (SWIG_arg_fail(3)) SWIG_fail;
38863 }
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 (arg1)->SetInitSize(arg2,arg3);
38867
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 Py_INCREF(Py_None); resultobj = Py_None;
38872 return resultobj;
38873 fail:
38874 return NULL;
38875 }
38876
38877
38878 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj;
38880 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38881 int arg2 ;
38882 int arg3 ;
38883 PyObject * obj0 = 0 ;
38884 PyObject * obj1 = 0 ;
38885 PyObject * obj2 = 0 ;
38886 char *kwnames[] = {
38887 (char *) "self",(char *) "width",(char *) "height", NULL
38888 };
38889
38890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38892 if (SWIG_arg_fail(1)) SWIG_fail;
38893 {
38894 arg2 = (int)(SWIG_As_int(obj1));
38895 if (SWIG_arg_fail(2)) SWIG_fail;
38896 }
38897 {
38898 arg3 = (int)(SWIG_As_int(obj2));
38899 if (SWIG_arg_fail(3)) SWIG_fail;
38900 }
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 (arg1)->SetRatio(arg2,arg3);
38904
38905 wxPyEndAllowThreads(__tstate);
38906 if (PyErr_Occurred()) SWIG_fail;
38907 }
38908 Py_INCREF(Py_None); resultobj = Py_None;
38909 return resultobj;
38910 fail:
38911 return NULL;
38912 }
38913
38914
38915 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38916 PyObject *resultobj;
38917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38918 wxSize *arg2 = 0 ;
38919 wxSize temp2 ;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 char *kwnames[] = {
38923 (char *) "self",(char *) "size", NULL
38924 };
38925
38926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38928 if (SWIG_arg_fail(1)) SWIG_fail;
38929 {
38930 arg2 = &temp2;
38931 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38932 }
38933 {
38934 PyThreadState* __tstate = wxPyBeginAllowThreads();
38935 (arg1)->SetRatio((wxSize const &)*arg2);
38936
38937 wxPyEndAllowThreads(__tstate);
38938 if (PyErr_Occurred()) SWIG_fail;
38939 }
38940 Py_INCREF(Py_None); resultobj = Py_None;
38941 return resultobj;
38942 fail:
38943 return NULL;
38944 }
38945
38946
38947 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38948 PyObject *resultobj;
38949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38950 float arg2 ;
38951 PyObject * obj0 = 0 ;
38952 PyObject * obj1 = 0 ;
38953 char *kwnames[] = {
38954 (char *) "self",(char *) "ratio", NULL
38955 };
38956
38957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38959 if (SWIG_arg_fail(1)) SWIG_fail;
38960 {
38961 arg2 = (float)(SWIG_As_float(obj1));
38962 if (SWIG_arg_fail(2)) SWIG_fail;
38963 }
38964 {
38965 PyThreadState* __tstate = wxPyBeginAllowThreads();
38966 (arg1)->SetRatio(arg2);
38967
38968 wxPyEndAllowThreads(__tstate);
38969 if (PyErr_Occurred()) SWIG_fail;
38970 }
38971 Py_INCREF(Py_None); resultobj = Py_None;
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38979 PyObject *resultobj;
38980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38981 float result;
38982 PyObject * obj0 = 0 ;
38983 char *kwnames[] = {
38984 (char *) "self", NULL
38985 };
38986
38987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38989 if (SWIG_arg_fail(1)) SWIG_fail;
38990 {
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (float)(arg1)->GetRatio();
38993
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 resultobj = SWIG_From_float((float)(result));
38999 }
39000 return resultobj;
39001 fail:
39002 return NULL;
39003 }
39004
39005
39006 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39007 PyObject *resultobj;
39008 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39009 wxRect result;
39010 PyObject * obj0 = 0 ;
39011 char *kwnames[] = {
39012 (char *) "self", NULL
39013 };
39014
39015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39017 if (SWIG_arg_fail(1)) SWIG_fail;
39018 {
39019 PyThreadState* __tstate = wxPyBeginAllowThreads();
39020 result = (arg1)->GetRect();
39021
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 {
39026 wxRect * resultptr;
39027 resultptr = new wxRect((wxRect &)(result));
39028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39029 }
39030 return resultobj;
39031 fail:
39032 return NULL;
39033 }
39034
39035
39036 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39037 PyObject *resultobj;
39038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39039 bool result;
39040 PyObject * obj0 = 0 ;
39041 char *kwnames[] = {
39042 (char *) "self", NULL
39043 };
39044
39045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39047 if (SWIG_arg_fail(1)) SWIG_fail;
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (bool)(arg1)->IsWindow();
39051
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 {
39056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39057 }
39058 return resultobj;
39059 fail:
39060 return NULL;
39061 }
39062
39063
39064 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj;
39066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39067 bool result;
39068 PyObject * obj0 = 0 ;
39069 char *kwnames[] = {
39070 (char *) "self", NULL
39071 };
39072
39073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39075 if (SWIG_arg_fail(1)) SWIG_fail;
39076 {
39077 PyThreadState* __tstate = wxPyBeginAllowThreads();
39078 result = (bool)(arg1)->IsSizer();
39079
39080 wxPyEndAllowThreads(__tstate);
39081 if (PyErr_Occurred()) SWIG_fail;
39082 }
39083 {
39084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39085 }
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39093 PyObject *resultobj;
39094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39095 bool result;
39096 PyObject * obj0 = 0 ;
39097 char *kwnames[] = {
39098 (char *) "self", NULL
39099 };
39100
39101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39103 if (SWIG_arg_fail(1)) SWIG_fail;
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 result = (bool)(arg1)->IsSpacer();
39107
39108 wxPyEndAllowThreads(__tstate);
39109 if (PyErr_Occurred()) SWIG_fail;
39110 }
39111 {
39112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39113 }
39114 return resultobj;
39115 fail:
39116 return NULL;
39117 }
39118
39119
39120 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39121 PyObject *resultobj;
39122 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39123 int arg2 ;
39124 PyObject * obj0 = 0 ;
39125 PyObject * obj1 = 0 ;
39126 char *kwnames[] = {
39127 (char *) "self",(char *) "proportion", NULL
39128 };
39129
39130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39132 if (SWIG_arg_fail(1)) SWIG_fail;
39133 {
39134 arg2 = (int)(SWIG_As_int(obj1));
39135 if (SWIG_arg_fail(2)) SWIG_fail;
39136 }
39137 {
39138 PyThreadState* __tstate = wxPyBeginAllowThreads();
39139 (arg1)->SetProportion(arg2);
39140
39141 wxPyEndAllowThreads(__tstate);
39142 if (PyErr_Occurred()) SWIG_fail;
39143 }
39144 Py_INCREF(Py_None); resultobj = Py_None;
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj;
39153 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39154 int result;
39155 PyObject * obj0 = 0 ;
39156 char *kwnames[] = {
39157 (char *) "self", NULL
39158 };
39159
39160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39162 if (SWIG_arg_fail(1)) SWIG_fail;
39163 {
39164 PyThreadState* __tstate = wxPyBeginAllowThreads();
39165 result = (int)(arg1)->GetProportion();
39166
39167 wxPyEndAllowThreads(__tstate);
39168 if (PyErr_Occurred()) SWIG_fail;
39169 }
39170 {
39171 resultobj = SWIG_From_int((int)(result));
39172 }
39173 return resultobj;
39174 fail:
39175 return NULL;
39176 }
39177
39178
39179 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39180 PyObject *resultobj;
39181 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39182 int arg2 ;
39183 PyObject * obj0 = 0 ;
39184 PyObject * obj1 = 0 ;
39185 char *kwnames[] = {
39186 (char *) "self",(char *) "flag", NULL
39187 };
39188
39189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39191 if (SWIG_arg_fail(1)) SWIG_fail;
39192 {
39193 arg2 = (int)(SWIG_As_int(obj1));
39194 if (SWIG_arg_fail(2)) SWIG_fail;
39195 }
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 (arg1)->SetFlag(arg2);
39199
39200 wxPyEndAllowThreads(__tstate);
39201 if (PyErr_Occurred()) SWIG_fail;
39202 }
39203 Py_INCREF(Py_None); resultobj = Py_None;
39204 return resultobj;
39205 fail:
39206 return NULL;
39207 }
39208
39209
39210 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39211 PyObject *resultobj;
39212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39213 int result;
39214 PyObject * obj0 = 0 ;
39215 char *kwnames[] = {
39216 (char *) "self", NULL
39217 };
39218
39219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39221 if (SWIG_arg_fail(1)) SWIG_fail;
39222 {
39223 PyThreadState* __tstate = wxPyBeginAllowThreads();
39224 result = (int)(arg1)->GetFlag();
39225
39226 wxPyEndAllowThreads(__tstate);
39227 if (PyErr_Occurred()) SWIG_fail;
39228 }
39229 {
39230 resultobj = SWIG_From_int((int)(result));
39231 }
39232 return resultobj;
39233 fail:
39234 return NULL;
39235 }
39236
39237
39238 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39239 PyObject *resultobj;
39240 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39241 int arg2 ;
39242 PyObject * obj0 = 0 ;
39243 PyObject * obj1 = 0 ;
39244 char *kwnames[] = {
39245 (char *) "self",(char *) "border", NULL
39246 };
39247
39248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39250 if (SWIG_arg_fail(1)) SWIG_fail;
39251 {
39252 arg2 = (int)(SWIG_As_int(obj1));
39253 if (SWIG_arg_fail(2)) SWIG_fail;
39254 }
39255 {
39256 PyThreadState* __tstate = wxPyBeginAllowThreads();
39257 (arg1)->SetBorder(arg2);
39258
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 Py_INCREF(Py_None); resultobj = Py_None;
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj;
39271 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39272 int result;
39273 PyObject * obj0 = 0 ;
39274 char *kwnames[] = {
39275 (char *) "self", NULL
39276 };
39277
39278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39280 if (SWIG_arg_fail(1)) SWIG_fail;
39281 {
39282 PyThreadState* __tstate = wxPyBeginAllowThreads();
39283 result = (int)(arg1)->GetBorder();
39284
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = SWIG_From_int((int)(result));
39290 }
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj;
39299 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39300 wxWindow *result;
39301 PyObject * obj0 = 0 ;
39302 char *kwnames[] = {
39303 (char *) "self", NULL
39304 };
39305
39306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39308 if (SWIG_arg_fail(1)) SWIG_fail;
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxWindow *)(arg1)->GetWindow();
39312
39313 wxPyEndAllowThreads(__tstate);
39314 if (PyErr_Occurred()) SWIG_fail;
39315 }
39316 {
39317 resultobj = wxPyMake_wxObject(result, 0);
39318 }
39319 return resultobj;
39320 fail:
39321 return NULL;
39322 }
39323
39324
39325 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39326 PyObject *resultobj;
39327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39328 wxWindow *arg2 = (wxWindow *) 0 ;
39329 PyObject * obj0 = 0 ;
39330 PyObject * obj1 = 0 ;
39331 char *kwnames[] = {
39332 (char *) "self",(char *) "window", NULL
39333 };
39334
39335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39337 if (SWIG_arg_fail(1)) SWIG_fail;
39338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39339 if (SWIG_arg_fail(2)) SWIG_fail;
39340 {
39341 PyThreadState* __tstate = wxPyBeginAllowThreads();
39342 (arg1)->SetWindow(arg2);
39343
39344 wxPyEndAllowThreads(__tstate);
39345 if (PyErr_Occurred()) SWIG_fail;
39346 }
39347 Py_INCREF(Py_None); resultobj = Py_None;
39348 return resultobj;
39349 fail:
39350 return NULL;
39351 }
39352
39353
39354 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39355 PyObject *resultobj;
39356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39357 wxSizer *result;
39358 PyObject * obj0 = 0 ;
39359 char *kwnames[] = {
39360 (char *) "self", NULL
39361 };
39362
39363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39365 if (SWIG_arg_fail(1)) SWIG_fail;
39366 {
39367 PyThreadState* __tstate = wxPyBeginAllowThreads();
39368 result = (wxSizer *)(arg1)->GetSizer();
39369
39370 wxPyEndAllowThreads(__tstate);
39371 if (PyErr_Occurred()) SWIG_fail;
39372 }
39373 {
39374 resultobj = wxPyMake_wxObject(result, 0);
39375 }
39376 return resultobj;
39377 fail:
39378 return NULL;
39379 }
39380
39381
39382 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39383 PyObject *resultobj;
39384 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39385 wxSizer *arg2 = (wxSizer *) 0 ;
39386 PyObject * obj0 = 0 ;
39387 PyObject * obj1 = 0 ;
39388 char *kwnames[] = {
39389 (char *) "self",(char *) "sizer", NULL
39390 };
39391
39392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39394 if (SWIG_arg_fail(1)) SWIG_fail;
39395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39396 if (SWIG_arg_fail(2)) SWIG_fail;
39397 {
39398 PyThreadState* __tstate = wxPyBeginAllowThreads();
39399 (arg1)->SetSizer(arg2);
39400
39401 wxPyEndAllowThreads(__tstate);
39402 if (PyErr_Occurred()) SWIG_fail;
39403 }
39404 Py_INCREF(Py_None); resultobj = Py_None;
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj;
39413 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39414 wxSize *result;
39415 PyObject * obj0 = 0 ;
39416 char *kwnames[] = {
39417 (char *) "self", NULL
39418 };
39419
39420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39422 if (SWIG_arg_fail(1)) SWIG_fail;
39423 {
39424 PyThreadState* __tstate = wxPyBeginAllowThreads();
39425 {
39426 wxSize const &_result_ref = (arg1)->GetSpacer();
39427 result = (wxSize *) &_result_ref;
39428 }
39429
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj;
39442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39443 wxSize *arg2 = 0 ;
39444 wxSize temp2 ;
39445 PyObject * obj0 = 0 ;
39446 PyObject * obj1 = 0 ;
39447 char *kwnames[] = {
39448 (char *) "self",(char *) "size", NULL
39449 };
39450
39451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39453 if (SWIG_arg_fail(1)) SWIG_fail;
39454 {
39455 arg2 = &temp2;
39456 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39457 }
39458 {
39459 PyThreadState* __tstate = wxPyBeginAllowThreads();
39460 (arg1)->SetSpacer((wxSize const &)*arg2);
39461
39462 wxPyEndAllowThreads(__tstate);
39463 if (PyErr_Occurred()) SWIG_fail;
39464 }
39465 Py_INCREF(Py_None); resultobj = Py_None;
39466 return resultobj;
39467 fail:
39468 return NULL;
39469 }
39470
39471
39472 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39473 PyObject *resultobj;
39474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39475 bool arg2 ;
39476 PyObject * obj0 = 0 ;
39477 PyObject * obj1 = 0 ;
39478 char *kwnames[] = {
39479 (char *) "self",(char *) "show", NULL
39480 };
39481
39482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39484 if (SWIG_arg_fail(1)) SWIG_fail;
39485 {
39486 arg2 = (bool)(SWIG_As_bool(obj1));
39487 if (SWIG_arg_fail(2)) SWIG_fail;
39488 }
39489 {
39490 PyThreadState* __tstate = wxPyBeginAllowThreads();
39491 (arg1)->Show(arg2);
39492
39493 wxPyEndAllowThreads(__tstate);
39494 if (PyErr_Occurred()) SWIG_fail;
39495 }
39496 Py_INCREF(Py_None); resultobj = Py_None;
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39504 PyObject *resultobj;
39505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39506 bool result;
39507 PyObject * obj0 = 0 ;
39508 char *kwnames[] = {
39509 (char *) "self", NULL
39510 };
39511
39512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39514 if (SWIG_arg_fail(1)) SWIG_fail;
39515 {
39516 PyThreadState* __tstate = wxPyBeginAllowThreads();
39517 result = (bool)(arg1)->IsShown();
39518
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39524 }
39525 return resultobj;
39526 fail:
39527 return NULL;
39528 }
39529
39530
39531 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39532 PyObject *resultobj;
39533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39534 wxPoint result;
39535 PyObject * obj0 = 0 ;
39536 char *kwnames[] = {
39537 (char *) "self", NULL
39538 };
39539
39540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39542 if (SWIG_arg_fail(1)) SWIG_fail;
39543 {
39544 PyThreadState* __tstate = wxPyBeginAllowThreads();
39545 result = (arg1)->GetPosition();
39546
39547 wxPyEndAllowThreads(__tstate);
39548 if (PyErr_Occurred()) SWIG_fail;
39549 }
39550 {
39551 wxPoint * resultptr;
39552 resultptr = new wxPoint((wxPoint &)(result));
39553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39554 }
39555 return resultobj;
39556 fail:
39557 return NULL;
39558 }
39559
39560
39561 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39562 PyObject *resultobj;
39563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39564 PyObject *result;
39565 PyObject * obj0 = 0 ;
39566 char *kwnames[] = {
39567 (char *) "self", NULL
39568 };
39569
39570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39572 if (SWIG_arg_fail(1)) SWIG_fail;
39573 {
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39576
39577 wxPyEndAllowThreads(__tstate);
39578 if (PyErr_Occurred()) SWIG_fail;
39579 }
39580 resultobj = result;
39581 return resultobj;
39582 fail:
39583 return NULL;
39584 }
39585
39586
39587 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39588 PyObject *obj;
39589 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39590 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39591 Py_INCREF(obj);
39592 return Py_BuildValue((char *)"");
39593 }
39594 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj;
39596 wxSizer *arg1 = (wxSizer *) 0 ;
39597 PyObject *arg2 = (PyObject *) 0 ;
39598 PyObject * obj0 = 0 ;
39599 PyObject * obj1 = 0 ;
39600 char *kwnames[] = {
39601 (char *) "self",(char *) "_self", NULL
39602 };
39603
39604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39606 if (SWIG_arg_fail(1)) SWIG_fail;
39607 arg2 = obj1;
39608 {
39609 PyThreadState* __tstate = wxPyBeginAllowThreads();
39610 wxSizer__setOORInfo(arg1,arg2);
39611
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 Py_INCREF(Py_None); resultobj = Py_None;
39616 return resultobj;
39617 fail:
39618 return NULL;
39619 }
39620
39621
39622 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39623 PyObject *resultobj;
39624 wxSizer *arg1 = (wxSizer *) 0 ;
39625 PyObject *arg2 = (PyObject *) 0 ;
39626 int arg3 = (int) 0 ;
39627 int arg4 = (int) 0 ;
39628 int arg5 = (int) 0 ;
39629 PyObject *arg6 = (PyObject *) NULL ;
39630 wxSizerItem *result;
39631 PyObject * obj0 = 0 ;
39632 PyObject * obj1 = 0 ;
39633 PyObject * obj2 = 0 ;
39634 PyObject * obj3 = 0 ;
39635 PyObject * obj4 = 0 ;
39636 PyObject * obj5 = 0 ;
39637 char *kwnames[] = {
39638 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39639 };
39640
39641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39643 if (SWIG_arg_fail(1)) SWIG_fail;
39644 arg2 = obj1;
39645 if (obj2) {
39646 {
39647 arg3 = (int)(SWIG_As_int(obj2));
39648 if (SWIG_arg_fail(3)) SWIG_fail;
39649 }
39650 }
39651 if (obj3) {
39652 {
39653 arg4 = (int)(SWIG_As_int(obj3));
39654 if (SWIG_arg_fail(4)) SWIG_fail;
39655 }
39656 }
39657 if (obj4) {
39658 {
39659 arg5 = (int)(SWIG_As_int(obj4));
39660 if (SWIG_arg_fail(5)) SWIG_fail;
39661 }
39662 }
39663 if (obj5) {
39664 arg6 = obj5;
39665 }
39666 {
39667 PyThreadState* __tstate = wxPyBeginAllowThreads();
39668 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39669
39670 wxPyEndAllowThreads(__tstate);
39671 if (PyErr_Occurred()) SWIG_fail;
39672 }
39673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39674 return resultobj;
39675 fail:
39676 return NULL;
39677 }
39678
39679
39680 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39681 PyObject *resultobj;
39682 wxSizer *arg1 = (wxSizer *) 0 ;
39683 int arg2 ;
39684 PyObject *arg3 = (PyObject *) 0 ;
39685 int arg4 = (int) 0 ;
39686 int arg5 = (int) 0 ;
39687 int arg6 = (int) 0 ;
39688 PyObject *arg7 = (PyObject *) NULL ;
39689 wxSizerItem *result;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 PyObject * obj2 = 0 ;
39693 PyObject * obj3 = 0 ;
39694 PyObject * obj4 = 0 ;
39695 PyObject * obj5 = 0 ;
39696 PyObject * obj6 = 0 ;
39697 char *kwnames[] = {
39698 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39699 };
39700
39701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39703 if (SWIG_arg_fail(1)) SWIG_fail;
39704 {
39705 arg2 = (int)(SWIG_As_int(obj1));
39706 if (SWIG_arg_fail(2)) SWIG_fail;
39707 }
39708 arg3 = obj2;
39709 if (obj3) {
39710 {
39711 arg4 = (int)(SWIG_As_int(obj3));
39712 if (SWIG_arg_fail(4)) SWIG_fail;
39713 }
39714 }
39715 if (obj4) {
39716 {
39717 arg5 = (int)(SWIG_As_int(obj4));
39718 if (SWIG_arg_fail(5)) SWIG_fail;
39719 }
39720 }
39721 if (obj5) {
39722 {
39723 arg6 = (int)(SWIG_As_int(obj5));
39724 if (SWIG_arg_fail(6)) SWIG_fail;
39725 }
39726 }
39727 if (obj6) {
39728 arg7 = obj6;
39729 }
39730 {
39731 PyThreadState* __tstate = wxPyBeginAllowThreads();
39732 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39733
39734 wxPyEndAllowThreads(__tstate);
39735 if (PyErr_Occurred()) SWIG_fail;
39736 }
39737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39738 return resultobj;
39739 fail:
39740 return NULL;
39741 }
39742
39743
39744 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39745 PyObject *resultobj;
39746 wxSizer *arg1 = (wxSizer *) 0 ;
39747 PyObject *arg2 = (PyObject *) 0 ;
39748 int arg3 = (int) 0 ;
39749 int arg4 = (int) 0 ;
39750 int arg5 = (int) 0 ;
39751 PyObject *arg6 = (PyObject *) NULL ;
39752 wxSizerItem *result;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 PyObject * obj2 = 0 ;
39756 PyObject * obj3 = 0 ;
39757 PyObject * obj4 = 0 ;
39758 PyObject * obj5 = 0 ;
39759 char *kwnames[] = {
39760 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39761 };
39762
39763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39765 if (SWIG_arg_fail(1)) SWIG_fail;
39766 arg2 = obj1;
39767 if (obj2) {
39768 {
39769 arg3 = (int)(SWIG_As_int(obj2));
39770 if (SWIG_arg_fail(3)) SWIG_fail;
39771 }
39772 }
39773 if (obj3) {
39774 {
39775 arg4 = (int)(SWIG_As_int(obj3));
39776 if (SWIG_arg_fail(4)) SWIG_fail;
39777 }
39778 }
39779 if (obj4) {
39780 {
39781 arg5 = (int)(SWIG_As_int(obj4));
39782 if (SWIG_arg_fail(5)) SWIG_fail;
39783 }
39784 }
39785 if (obj5) {
39786 arg6 = obj5;
39787 }
39788 {
39789 PyThreadState* __tstate = wxPyBeginAllowThreads();
39790 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39791
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39796 return resultobj;
39797 fail:
39798 return NULL;
39799 }
39800
39801
39802 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39803 PyObject *resultobj;
39804 wxSizer *arg1 = (wxSizer *) 0 ;
39805 PyObject *arg2 = (PyObject *) 0 ;
39806 bool result;
39807 PyObject * obj0 = 0 ;
39808 PyObject * obj1 = 0 ;
39809 char *kwnames[] = {
39810 (char *) "self",(char *) "item", NULL
39811 };
39812
39813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39815 if (SWIG_arg_fail(1)) SWIG_fail;
39816 arg2 = obj1;
39817 {
39818 PyThreadState* __tstate = wxPyBeginAllowThreads();
39819 result = (bool)wxSizer_Remove(arg1,arg2);
39820
39821 wxPyEndAllowThreads(__tstate);
39822 if (PyErr_Occurred()) SWIG_fail;
39823 }
39824 {
39825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39826 }
39827 return resultobj;
39828 fail:
39829 return NULL;
39830 }
39831
39832
39833 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39834 PyObject *resultobj;
39835 wxSizer *arg1 = (wxSizer *) 0 ;
39836 PyObject *arg2 = (PyObject *) 0 ;
39837 bool result;
39838 PyObject * obj0 = 0 ;
39839 PyObject * obj1 = 0 ;
39840 char *kwnames[] = {
39841 (char *) "self",(char *) "item", NULL
39842 };
39843
39844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39846 if (SWIG_arg_fail(1)) SWIG_fail;
39847 arg2 = obj1;
39848 {
39849 PyThreadState* __tstate = wxPyBeginAllowThreads();
39850 result = (bool)wxSizer_Detach(arg1,arg2);
39851
39852 wxPyEndAllowThreads(__tstate);
39853 if (PyErr_Occurred()) SWIG_fail;
39854 }
39855 {
39856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39857 }
39858 return resultobj;
39859 fail:
39860 return NULL;
39861 }
39862
39863
39864 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39865 PyObject *resultobj;
39866 wxSizer *arg1 = (wxSizer *) 0 ;
39867 PyObject *arg2 = (PyObject *) 0 ;
39868 wxSizerItem *result;
39869 PyObject * obj0 = 0 ;
39870 PyObject * obj1 = 0 ;
39871 char *kwnames[] = {
39872 (char *) "self",(char *) "item", NULL
39873 };
39874
39875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39877 if (SWIG_arg_fail(1)) SWIG_fail;
39878 arg2 = obj1;
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39882
39883 wxPyEndAllowThreads(__tstate);
39884 if (PyErr_Occurred()) SWIG_fail;
39885 }
39886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39887 return resultobj;
39888 fail:
39889 return NULL;
39890 }
39891
39892
39893 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39894 PyObject *resultobj;
39895 wxSizer *arg1 = (wxSizer *) 0 ;
39896 PyObject *arg2 = (PyObject *) 0 ;
39897 wxSize *arg3 = 0 ;
39898 wxSize temp3 ;
39899 PyObject * obj0 = 0 ;
39900 PyObject * obj1 = 0 ;
39901 PyObject * obj2 = 0 ;
39902 char *kwnames[] = {
39903 (char *) "self",(char *) "item",(char *) "size", NULL
39904 };
39905
39906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(1)) SWIG_fail;
39909 arg2 = obj1;
39910 {
39911 arg3 = &temp3;
39912 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39913 }
39914 {
39915 PyThreadState* __tstate = wxPyBeginAllowThreads();
39916 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39917
39918 wxPyEndAllowThreads(__tstate);
39919 if (PyErr_Occurred()) SWIG_fail;
39920 }
39921 Py_INCREF(Py_None); resultobj = Py_None;
39922 return resultobj;
39923 fail:
39924 return NULL;
39925 }
39926
39927
39928 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39929 PyObject *resultobj;
39930 wxSizer *arg1 = (wxSizer *) 0 ;
39931 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39932 wxSizerItem *result;
39933 PyObject * obj0 = 0 ;
39934 PyObject * obj1 = 0 ;
39935 char *kwnames[] = {
39936 (char *) "self",(char *) "item", NULL
39937 };
39938
39939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39941 if (SWIG_arg_fail(1)) SWIG_fail;
39942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39943 if (SWIG_arg_fail(2)) SWIG_fail;
39944 {
39945 PyThreadState* __tstate = wxPyBeginAllowThreads();
39946 result = (wxSizerItem *)(arg1)->Add(arg2);
39947
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39952 return resultobj;
39953 fail:
39954 return NULL;
39955 }
39956
39957
39958 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39959 PyObject *resultobj;
39960 wxSizer *arg1 = (wxSizer *) 0 ;
39961 size_t arg2 ;
39962 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39963 wxSizerItem *result;
39964 PyObject * obj0 = 0 ;
39965 PyObject * obj1 = 0 ;
39966 PyObject * obj2 = 0 ;
39967 char *kwnames[] = {
39968 (char *) "self",(char *) "index",(char *) "item", NULL
39969 };
39970
39971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39973 if (SWIG_arg_fail(1)) SWIG_fail;
39974 {
39975 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39976 if (SWIG_arg_fail(2)) SWIG_fail;
39977 }
39978 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(3)) SWIG_fail;
39980 {
39981 PyThreadState* __tstate = wxPyBeginAllowThreads();
39982 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39983
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj;
39996 wxSizer *arg1 = (wxSizer *) 0 ;
39997 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39998 wxSizerItem *result;
39999 PyObject * obj0 = 0 ;
40000 PyObject * obj1 = 0 ;
40001 char *kwnames[] = {
40002 (char *) "self",(char *) "item", NULL
40003 };
40004
40005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40007 if (SWIG_arg_fail(1)) SWIG_fail;
40008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40009 if (SWIG_arg_fail(2)) SWIG_fail;
40010 {
40011 PyThreadState* __tstate = wxPyBeginAllowThreads();
40012 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40013
40014 wxPyEndAllowThreads(__tstate);
40015 if (PyErr_Occurred()) SWIG_fail;
40016 }
40017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40018 return resultobj;
40019 fail:
40020 return NULL;
40021 }
40022
40023
40024 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40025 PyObject *resultobj;
40026 wxSizer *arg1 = (wxSizer *) 0 ;
40027 int arg2 ;
40028 int arg3 ;
40029 int arg4 ;
40030 int arg5 ;
40031 PyObject * obj0 = 0 ;
40032 PyObject * obj1 = 0 ;
40033 PyObject * obj2 = 0 ;
40034 PyObject * obj3 = 0 ;
40035 PyObject * obj4 = 0 ;
40036 char *kwnames[] = {
40037 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40038 };
40039
40040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40042 if (SWIG_arg_fail(1)) SWIG_fail;
40043 {
40044 arg2 = (int)(SWIG_As_int(obj1));
40045 if (SWIG_arg_fail(2)) SWIG_fail;
40046 }
40047 {
40048 arg3 = (int)(SWIG_As_int(obj2));
40049 if (SWIG_arg_fail(3)) SWIG_fail;
40050 }
40051 {
40052 arg4 = (int)(SWIG_As_int(obj3));
40053 if (SWIG_arg_fail(4)) SWIG_fail;
40054 }
40055 {
40056 arg5 = (int)(SWIG_As_int(obj4));
40057 if (SWIG_arg_fail(5)) SWIG_fail;
40058 }
40059 {
40060 PyThreadState* __tstate = wxPyBeginAllowThreads();
40061 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40062
40063 wxPyEndAllowThreads(__tstate);
40064 if (PyErr_Occurred()) SWIG_fail;
40065 }
40066 Py_INCREF(Py_None); resultobj = Py_None;
40067 return resultobj;
40068 fail:
40069 return NULL;
40070 }
40071
40072
40073 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40074 PyObject *resultobj;
40075 wxSizer *arg1 = (wxSizer *) 0 ;
40076 wxSize *arg2 = 0 ;
40077 wxSize temp2 ;
40078 PyObject * obj0 = 0 ;
40079 PyObject * obj1 = 0 ;
40080 char *kwnames[] = {
40081 (char *) "self",(char *) "size", NULL
40082 };
40083
40084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40086 if (SWIG_arg_fail(1)) SWIG_fail;
40087 {
40088 arg2 = &temp2;
40089 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40090 }
40091 {
40092 PyThreadState* __tstate = wxPyBeginAllowThreads();
40093 (arg1)->SetMinSize((wxSize const &)*arg2);
40094
40095 wxPyEndAllowThreads(__tstate);
40096 if (PyErr_Occurred()) SWIG_fail;
40097 }
40098 Py_INCREF(Py_None); resultobj = Py_None;
40099 return resultobj;
40100 fail:
40101 return NULL;
40102 }
40103
40104
40105 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40106 PyObject *resultobj;
40107 wxSizer *arg1 = (wxSizer *) 0 ;
40108 wxSize result;
40109 PyObject * obj0 = 0 ;
40110 char *kwnames[] = {
40111 (char *) "self", NULL
40112 };
40113
40114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40116 if (SWIG_arg_fail(1)) SWIG_fail;
40117 {
40118 PyThreadState* __tstate = wxPyBeginAllowThreads();
40119 result = (arg1)->GetSize();
40120
40121 wxPyEndAllowThreads(__tstate);
40122 if (PyErr_Occurred()) SWIG_fail;
40123 }
40124 {
40125 wxSize * resultptr;
40126 resultptr = new wxSize((wxSize &)(result));
40127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40128 }
40129 return resultobj;
40130 fail:
40131 return NULL;
40132 }
40133
40134
40135 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40136 PyObject *resultobj;
40137 wxSizer *arg1 = (wxSizer *) 0 ;
40138 wxPoint result;
40139 PyObject * obj0 = 0 ;
40140 char *kwnames[] = {
40141 (char *) "self", NULL
40142 };
40143
40144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40146 if (SWIG_arg_fail(1)) SWIG_fail;
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 result = (arg1)->GetPosition();
40150
40151 wxPyEndAllowThreads(__tstate);
40152 if (PyErr_Occurred()) SWIG_fail;
40153 }
40154 {
40155 wxPoint * resultptr;
40156 resultptr = new wxPoint((wxPoint &)(result));
40157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40158 }
40159 return resultobj;
40160 fail:
40161 return NULL;
40162 }
40163
40164
40165 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40166 PyObject *resultobj;
40167 wxSizer *arg1 = (wxSizer *) 0 ;
40168 wxSize result;
40169 PyObject * obj0 = 0 ;
40170 char *kwnames[] = {
40171 (char *) "self", NULL
40172 };
40173
40174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40176 if (SWIG_arg_fail(1)) SWIG_fail;
40177 {
40178 PyThreadState* __tstate = wxPyBeginAllowThreads();
40179 result = (arg1)->GetMinSize();
40180
40181 wxPyEndAllowThreads(__tstate);
40182 if (PyErr_Occurred()) SWIG_fail;
40183 }
40184 {
40185 wxSize * resultptr;
40186 resultptr = new wxSize((wxSize &)(result));
40187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40188 }
40189 return resultobj;
40190 fail:
40191 return NULL;
40192 }
40193
40194
40195 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40196 PyObject *resultobj;
40197 wxSizer *arg1 = (wxSizer *) 0 ;
40198 PyObject * obj0 = 0 ;
40199 char *kwnames[] = {
40200 (char *) "self", NULL
40201 };
40202
40203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40205 if (SWIG_arg_fail(1)) SWIG_fail;
40206 {
40207 PyThreadState* __tstate = wxPyBeginAllowThreads();
40208 (arg1)->RecalcSizes();
40209
40210 wxPyEndAllowThreads(__tstate);
40211 if (PyErr_Occurred()) SWIG_fail;
40212 }
40213 Py_INCREF(Py_None); resultobj = Py_None;
40214 return resultobj;
40215 fail:
40216 return NULL;
40217 }
40218
40219
40220 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40221 PyObject *resultobj;
40222 wxSizer *arg1 = (wxSizer *) 0 ;
40223 wxSize result;
40224 PyObject * obj0 = 0 ;
40225 char *kwnames[] = {
40226 (char *) "self", NULL
40227 };
40228
40229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40231 if (SWIG_arg_fail(1)) SWIG_fail;
40232 {
40233 PyThreadState* __tstate = wxPyBeginAllowThreads();
40234 result = (arg1)->CalcMin();
40235
40236 wxPyEndAllowThreads(__tstate);
40237 if (PyErr_Occurred()) SWIG_fail;
40238 }
40239 {
40240 wxSize * resultptr;
40241 resultptr = new wxSize((wxSize &)(result));
40242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40243 }
40244 return resultobj;
40245 fail:
40246 return NULL;
40247 }
40248
40249
40250 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40251 PyObject *resultobj;
40252 wxSizer *arg1 = (wxSizer *) 0 ;
40253 PyObject * obj0 = 0 ;
40254 char *kwnames[] = {
40255 (char *) "self", NULL
40256 };
40257
40258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(1)) SWIG_fail;
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->Layout();
40264
40265 wxPyEndAllowThreads(__tstate);
40266 if (PyErr_Occurred()) SWIG_fail;
40267 }
40268 Py_INCREF(Py_None); resultobj = Py_None;
40269 return resultobj;
40270 fail:
40271 return NULL;
40272 }
40273
40274
40275 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj;
40277 wxSizer *arg1 = (wxSizer *) 0 ;
40278 wxWindow *arg2 = (wxWindow *) 0 ;
40279 wxSize result;
40280 PyObject * obj0 = 0 ;
40281 PyObject * obj1 = 0 ;
40282 char *kwnames[] = {
40283 (char *) "self",(char *) "window", NULL
40284 };
40285
40286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40288 if (SWIG_arg_fail(1)) SWIG_fail;
40289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40290 if (SWIG_arg_fail(2)) SWIG_fail;
40291 {
40292 PyThreadState* __tstate = wxPyBeginAllowThreads();
40293 result = (arg1)->Fit(arg2);
40294
40295 wxPyEndAllowThreads(__tstate);
40296 if (PyErr_Occurred()) SWIG_fail;
40297 }
40298 {
40299 wxSize * resultptr;
40300 resultptr = new wxSize((wxSize &)(result));
40301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40302 }
40303 return resultobj;
40304 fail:
40305 return NULL;
40306 }
40307
40308
40309 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40310 PyObject *resultobj;
40311 wxSizer *arg1 = (wxSizer *) 0 ;
40312 wxWindow *arg2 = (wxWindow *) 0 ;
40313 PyObject * obj0 = 0 ;
40314 PyObject * obj1 = 0 ;
40315 char *kwnames[] = {
40316 (char *) "self",(char *) "window", NULL
40317 };
40318
40319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40321 if (SWIG_arg_fail(1)) SWIG_fail;
40322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40323 if (SWIG_arg_fail(2)) SWIG_fail;
40324 {
40325 PyThreadState* __tstate = wxPyBeginAllowThreads();
40326 (arg1)->FitInside(arg2);
40327
40328 wxPyEndAllowThreads(__tstate);
40329 if (PyErr_Occurred()) SWIG_fail;
40330 }
40331 Py_INCREF(Py_None); resultobj = Py_None;
40332 return resultobj;
40333 fail:
40334 return NULL;
40335 }
40336
40337
40338 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40339 PyObject *resultobj;
40340 wxSizer *arg1 = (wxSizer *) 0 ;
40341 wxWindow *arg2 = (wxWindow *) 0 ;
40342 PyObject * obj0 = 0 ;
40343 PyObject * obj1 = 0 ;
40344 char *kwnames[] = {
40345 (char *) "self",(char *) "window", NULL
40346 };
40347
40348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40350 if (SWIG_arg_fail(1)) SWIG_fail;
40351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40352 if (SWIG_arg_fail(2)) SWIG_fail;
40353 {
40354 PyThreadState* __tstate = wxPyBeginAllowThreads();
40355 (arg1)->SetSizeHints(arg2);
40356
40357 wxPyEndAllowThreads(__tstate);
40358 if (PyErr_Occurred()) SWIG_fail;
40359 }
40360 Py_INCREF(Py_None); resultobj = Py_None;
40361 return resultobj;
40362 fail:
40363 return NULL;
40364 }
40365
40366
40367 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40368 PyObject *resultobj;
40369 wxSizer *arg1 = (wxSizer *) 0 ;
40370 wxWindow *arg2 = (wxWindow *) 0 ;
40371 PyObject * obj0 = 0 ;
40372 PyObject * obj1 = 0 ;
40373 char *kwnames[] = {
40374 (char *) "self",(char *) "window", NULL
40375 };
40376
40377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40379 if (SWIG_arg_fail(1)) SWIG_fail;
40380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40381 if (SWIG_arg_fail(2)) SWIG_fail;
40382 {
40383 PyThreadState* __tstate = wxPyBeginAllowThreads();
40384 (arg1)->SetVirtualSizeHints(arg2);
40385
40386 wxPyEndAllowThreads(__tstate);
40387 if (PyErr_Occurred()) SWIG_fail;
40388 }
40389 Py_INCREF(Py_None); resultobj = Py_None;
40390 return resultobj;
40391 fail:
40392 return NULL;
40393 }
40394
40395
40396 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40397 PyObject *resultobj;
40398 wxSizer *arg1 = (wxSizer *) 0 ;
40399 bool arg2 = (bool) false ;
40400 PyObject * obj0 = 0 ;
40401 PyObject * obj1 = 0 ;
40402 char *kwnames[] = {
40403 (char *) "self",(char *) "deleteWindows", NULL
40404 };
40405
40406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40408 if (SWIG_arg_fail(1)) SWIG_fail;
40409 if (obj1) {
40410 {
40411 arg2 = (bool)(SWIG_As_bool(obj1));
40412 if (SWIG_arg_fail(2)) SWIG_fail;
40413 }
40414 }
40415 {
40416 PyThreadState* __tstate = wxPyBeginAllowThreads();
40417 (arg1)->Clear(arg2);
40418
40419 wxPyEndAllowThreads(__tstate);
40420 if (PyErr_Occurred()) SWIG_fail;
40421 }
40422 Py_INCREF(Py_None); resultobj = Py_None;
40423 return resultobj;
40424 fail:
40425 return NULL;
40426 }
40427
40428
40429 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40430 PyObject *resultobj;
40431 wxSizer *arg1 = (wxSizer *) 0 ;
40432 PyObject * obj0 = 0 ;
40433 char *kwnames[] = {
40434 (char *) "self", NULL
40435 };
40436
40437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40439 if (SWIG_arg_fail(1)) SWIG_fail;
40440 {
40441 PyThreadState* __tstate = wxPyBeginAllowThreads();
40442 (arg1)->DeleteWindows();
40443
40444 wxPyEndAllowThreads(__tstate);
40445 if (PyErr_Occurred()) SWIG_fail;
40446 }
40447 Py_INCREF(Py_None); resultobj = Py_None;
40448 return resultobj;
40449 fail:
40450 return NULL;
40451 }
40452
40453
40454 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj;
40456 wxSizer *arg1 = (wxSizer *) 0 ;
40457 PyObject *result;
40458 PyObject * obj0 = 0 ;
40459 char *kwnames[] = {
40460 (char *) "self", NULL
40461 };
40462
40463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40465 if (SWIG_arg_fail(1)) SWIG_fail;
40466 {
40467 PyThreadState* __tstate = wxPyBeginAllowThreads();
40468 result = (PyObject *)wxSizer_GetChildren(arg1);
40469
40470 wxPyEndAllowThreads(__tstate);
40471 if (PyErr_Occurred()) SWIG_fail;
40472 }
40473 resultobj = result;
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40481 PyObject *resultobj;
40482 wxSizer *arg1 = (wxSizer *) 0 ;
40483 PyObject *arg2 = (PyObject *) 0 ;
40484 bool arg3 = (bool) true ;
40485 bool arg4 = (bool) false ;
40486 bool result;
40487 PyObject * obj0 = 0 ;
40488 PyObject * obj1 = 0 ;
40489 PyObject * obj2 = 0 ;
40490 PyObject * obj3 = 0 ;
40491 char *kwnames[] = {
40492 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40493 };
40494
40495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40497 if (SWIG_arg_fail(1)) SWIG_fail;
40498 arg2 = obj1;
40499 if (obj2) {
40500 {
40501 arg3 = (bool)(SWIG_As_bool(obj2));
40502 if (SWIG_arg_fail(3)) SWIG_fail;
40503 }
40504 }
40505 if (obj3) {
40506 {
40507 arg4 = (bool)(SWIG_As_bool(obj3));
40508 if (SWIG_arg_fail(4)) SWIG_fail;
40509 }
40510 }
40511 {
40512 PyThreadState* __tstate = wxPyBeginAllowThreads();
40513 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40514
40515 wxPyEndAllowThreads(__tstate);
40516 if (PyErr_Occurred()) SWIG_fail;
40517 }
40518 {
40519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40520 }
40521 return resultobj;
40522 fail:
40523 return NULL;
40524 }
40525
40526
40527 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40528 PyObject *resultobj;
40529 wxSizer *arg1 = (wxSizer *) 0 ;
40530 PyObject *arg2 = (PyObject *) 0 ;
40531 bool result;
40532 PyObject * obj0 = 0 ;
40533 PyObject * obj1 = 0 ;
40534 char *kwnames[] = {
40535 (char *) "self",(char *) "item", NULL
40536 };
40537
40538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40540 if (SWIG_arg_fail(1)) SWIG_fail;
40541 arg2 = obj1;
40542 {
40543 PyThreadState* __tstate = wxPyBeginAllowThreads();
40544 result = (bool)wxSizer_IsShown(arg1,arg2);
40545
40546 wxPyEndAllowThreads(__tstate);
40547 if (PyErr_Occurred()) SWIG_fail;
40548 }
40549 {
40550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40551 }
40552 return resultobj;
40553 fail:
40554 return NULL;
40555 }
40556
40557
40558 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40559 PyObject *resultobj;
40560 wxSizer *arg1 = (wxSizer *) 0 ;
40561 bool arg2 ;
40562 PyObject * obj0 = 0 ;
40563 PyObject * obj1 = 0 ;
40564 char *kwnames[] = {
40565 (char *) "self",(char *) "show", NULL
40566 };
40567
40568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40570 if (SWIG_arg_fail(1)) SWIG_fail;
40571 {
40572 arg2 = (bool)(SWIG_As_bool(obj1));
40573 if (SWIG_arg_fail(2)) SWIG_fail;
40574 }
40575 {
40576 PyThreadState* __tstate = wxPyBeginAllowThreads();
40577 (arg1)->ShowItems(arg2);
40578
40579 wxPyEndAllowThreads(__tstate);
40580 if (PyErr_Occurred()) SWIG_fail;
40581 }
40582 Py_INCREF(Py_None); resultobj = Py_None;
40583 return resultobj;
40584 fail:
40585 return NULL;
40586 }
40587
40588
40589 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40590 PyObject *obj;
40591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40592 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40593 Py_INCREF(obj);
40594 return Py_BuildValue((char *)"");
40595 }
40596 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40597 PyObject *resultobj;
40598 wxPySizer *result;
40599 char *kwnames[] = {
40600 NULL
40601 };
40602
40603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40604 {
40605 PyThreadState* __tstate = wxPyBeginAllowThreads();
40606 result = (wxPySizer *)new wxPySizer();
40607
40608 wxPyEndAllowThreads(__tstate);
40609 if (PyErr_Occurred()) SWIG_fail;
40610 }
40611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40612 return resultobj;
40613 fail:
40614 return NULL;
40615 }
40616
40617
40618 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40619 PyObject *resultobj;
40620 wxPySizer *arg1 = (wxPySizer *) 0 ;
40621 PyObject *arg2 = (PyObject *) 0 ;
40622 PyObject *arg3 = (PyObject *) 0 ;
40623 PyObject * obj0 = 0 ;
40624 PyObject * obj1 = 0 ;
40625 PyObject * obj2 = 0 ;
40626 char *kwnames[] = {
40627 (char *) "self",(char *) "self",(char *) "_class", NULL
40628 };
40629
40630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40632 if (SWIG_arg_fail(1)) SWIG_fail;
40633 arg2 = obj1;
40634 arg3 = obj2;
40635 {
40636 PyThreadState* __tstate = wxPyBeginAllowThreads();
40637 (arg1)->_setCallbackInfo(arg2,arg3);
40638
40639 wxPyEndAllowThreads(__tstate);
40640 if (PyErr_Occurred()) SWIG_fail;
40641 }
40642 Py_INCREF(Py_None); resultobj = Py_None;
40643 return resultobj;
40644 fail:
40645 return NULL;
40646 }
40647
40648
40649 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40650 PyObject *obj;
40651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40652 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40653 Py_INCREF(obj);
40654 return Py_BuildValue((char *)"");
40655 }
40656 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40657 PyObject *resultobj;
40658 int arg1 = (int) wxHORIZONTAL ;
40659 wxBoxSizer *result;
40660 PyObject * obj0 = 0 ;
40661 char *kwnames[] = {
40662 (char *) "orient", NULL
40663 };
40664
40665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40666 if (obj0) {
40667 {
40668 arg1 = (int)(SWIG_As_int(obj0));
40669 if (SWIG_arg_fail(1)) SWIG_fail;
40670 }
40671 }
40672 {
40673 PyThreadState* __tstate = wxPyBeginAllowThreads();
40674 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40675
40676 wxPyEndAllowThreads(__tstate);
40677 if (PyErr_Occurred()) SWIG_fail;
40678 }
40679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40687 PyObject *resultobj;
40688 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40689 int result;
40690 PyObject * obj0 = 0 ;
40691 char *kwnames[] = {
40692 (char *) "self", NULL
40693 };
40694
40695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40697 if (SWIG_arg_fail(1)) SWIG_fail;
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 result = (int)(arg1)->GetOrientation();
40701
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 {
40706 resultobj = SWIG_From_int((int)(result));
40707 }
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40715 PyObject *resultobj;
40716 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40717 int arg2 ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 char *kwnames[] = {
40721 (char *) "self",(char *) "orient", NULL
40722 };
40723
40724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40726 if (SWIG_arg_fail(1)) SWIG_fail;
40727 {
40728 arg2 = (int)(SWIG_As_int(obj1));
40729 if (SWIG_arg_fail(2)) SWIG_fail;
40730 }
40731 {
40732 PyThreadState* __tstate = wxPyBeginAllowThreads();
40733 (arg1)->SetOrientation(arg2);
40734
40735 wxPyEndAllowThreads(__tstate);
40736 if (PyErr_Occurred()) SWIG_fail;
40737 }
40738 Py_INCREF(Py_None); resultobj = Py_None;
40739 return resultobj;
40740 fail:
40741 return NULL;
40742 }
40743
40744
40745 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40746 PyObject *obj;
40747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40748 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40749 Py_INCREF(obj);
40750 return Py_BuildValue((char *)"");
40751 }
40752 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40753 PyObject *resultobj;
40754 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40755 int arg2 = (int) wxHORIZONTAL ;
40756 wxStaticBoxSizer *result;
40757 PyObject * obj0 = 0 ;
40758 PyObject * obj1 = 0 ;
40759 char *kwnames[] = {
40760 (char *) "box",(char *) "orient", NULL
40761 };
40762
40763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40765 if (SWIG_arg_fail(1)) SWIG_fail;
40766 if (obj1) {
40767 {
40768 arg2 = (int)(SWIG_As_int(obj1));
40769 if (SWIG_arg_fail(2)) SWIG_fail;
40770 }
40771 }
40772 {
40773 PyThreadState* __tstate = wxPyBeginAllowThreads();
40774 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40775
40776 wxPyEndAllowThreads(__tstate);
40777 if (PyErr_Occurred()) SWIG_fail;
40778 }
40779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40780 return resultobj;
40781 fail:
40782 return NULL;
40783 }
40784
40785
40786 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40787 PyObject *resultobj;
40788 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40789 wxStaticBox *result;
40790 PyObject * obj0 = 0 ;
40791 char *kwnames[] = {
40792 (char *) "self", NULL
40793 };
40794
40795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40797 if (SWIG_arg_fail(1)) SWIG_fail;
40798 {
40799 PyThreadState* __tstate = wxPyBeginAllowThreads();
40800 result = (wxStaticBox *)(arg1)->GetStaticBox();
40801
40802 wxPyEndAllowThreads(__tstate);
40803 if (PyErr_Occurred()) SWIG_fail;
40804 }
40805 {
40806 resultobj = wxPyMake_wxObject(result, 0);
40807 }
40808 return resultobj;
40809 fail:
40810 return NULL;
40811 }
40812
40813
40814 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40815 PyObject *obj;
40816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40817 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40818 Py_INCREF(obj);
40819 return Py_BuildValue((char *)"");
40820 }
40821 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj;
40823 int arg1 = (int) 1 ;
40824 int arg2 = (int) 0 ;
40825 int arg3 = (int) 0 ;
40826 int arg4 = (int) 0 ;
40827 wxGridSizer *result;
40828 PyObject * obj0 = 0 ;
40829 PyObject * obj1 = 0 ;
40830 PyObject * obj2 = 0 ;
40831 PyObject * obj3 = 0 ;
40832 char *kwnames[] = {
40833 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40834 };
40835
40836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40837 if (obj0) {
40838 {
40839 arg1 = (int)(SWIG_As_int(obj0));
40840 if (SWIG_arg_fail(1)) SWIG_fail;
40841 }
40842 }
40843 if (obj1) {
40844 {
40845 arg2 = (int)(SWIG_As_int(obj1));
40846 if (SWIG_arg_fail(2)) SWIG_fail;
40847 }
40848 }
40849 if (obj2) {
40850 {
40851 arg3 = (int)(SWIG_As_int(obj2));
40852 if (SWIG_arg_fail(3)) SWIG_fail;
40853 }
40854 }
40855 if (obj3) {
40856 {
40857 arg4 = (int)(SWIG_As_int(obj3));
40858 if (SWIG_arg_fail(4)) SWIG_fail;
40859 }
40860 }
40861 {
40862 PyThreadState* __tstate = wxPyBeginAllowThreads();
40863 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40864
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40876 PyObject *resultobj;
40877 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40878 int arg2 ;
40879 PyObject * obj0 = 0 ;
40880 PyObject * obj1 = 0 ;
40881 char *kwnames[] = {
40882 (char *) "self",(char *) "cols", NULL
40883 };
40884
40885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40887 if (SWIG_arg_fail(1)) SWIG_fail;
40888 {
40889 arg2 = (int)(SWIG_As_int(obj1));
40890 if (SWIG_arg_fail(2)) SWIG_fail;
40891 }
40892 {
40893 PyThreadState* __tstate = wxPyBeginAllowThreads();
40894 (arg1)->SetCols(arg2);
40895
40896 wxPyEndAllowThreads(__tstate);
40897 if (PyErr_Occurred()) SWIG_fail;
40898 }
40899 Py_INCREF(Py_None); resultobj = Py_None;
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj;
40908 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40909 int arg2 ;
40910 PyObject * obj0 = 0 ;
40911 PyObject * obj1 = 0 ;
40912 char *kwnames[] = {
40913 (char *) "self",(char *) "rows", NULL
40914 };
40915
40916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40918 if (SWIG_arg_fail(1)) SWIG_fail;
40919 {
40920 arg2 = (int)(SWIG_As_int(obj1));
40921 if (SWIG_arg_fail(2)) SWIG_fail;
40922 }
40923 {
40924 PyThreadState* __tstate = wxPyBeginAllowThreads();
40925 (arg1)->SetRows(arg2);
40926
40927 wxPyEndAllowThreads(__tstate);
40928 if (PyErr_Occurred()) SWIG_fail;
40929 }
40930 Py_INCREF(Py_None); resultobj = Py_None;
40931 return resultobj;
40932 fail:
40933 return NULL;
40934 }
40935
40936
40937 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40938 PyObject *resultobj;
40939 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40940 int arg2 ;
40941 PyObject * obj0 = 0 ;
40942 PyObject * obj1 = 0 ;
40943 char *kwnames[] = {
40944 (char *) "self",(char *) "gap", NULL
40945 };
40946
40947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40949 if (SWIG_arg_fail(1)) SWIG_fail;
40950 {
40951 arg2 = (int)(SWIG_As_int(obj1));
40952 if (SWIG_arg_fail(2)) SWIG_fail;
40953 }
40954 {
40955 PyThreadState* __tstate = wxPyBeginAllowThreads();
40956 (arg1)->SetVGap(arg2);
40957
40958 wxPyEndAllowThreads(__tstate);
40959 if (PyErr_Occurred()) SWIG_fail;
40960 }
40961 Py_INCREF(Py_None); resultobj = Py_None;
40962 return resultobj;
40963 fail:
40964 return NULL;
40965 }
40966
40967
40968 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40969 PyObject *resultobj;
40970 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40971 int arg2 ;
40972 PyObject * obj0 = 0 ;
40973 PyObject * obj1 = 0 ;
40974 char *kwnames[] = {
40975 (char *) "self",(char *) "gap", NULL
40976 };
40977
40978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40980 if (SWIG_arg_fail(1)) SWIG_fail;
40981 {
40982 arg2 = (int)(SWIG_As_int(obj1));
40983 if (SWIG_arg_fail(2)) SWIG_fail;
40984 }
40985 {
40986 PyThreadState* __tstate = wxPyBeginAllowThreads();
40987 (arg1)->SetHGap(arg2);
40988
40989 wxPyEndAllowThreads(__tstate);
40990 if (PyErr_Occurred()) SWIG_fail;
40991 }
40992 Py_INCREF(Py_None); resultobj = Py_None;
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj;
41001 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41002 int result;
41003 PyObject * obj0 = 0 ;
41004 char *kwnames[] = {
41005 (char *) "self", NULL
41006 };
41007
41008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41010 if (SWIG_arg_fail(1)) SWIG_fail;
41011 {
41012 PyThreadState* __tstate = wxPyBeginAllowThreads();
41013 result = (int)(arg1)->GetCols();
41014
41015 wxPyEndAllowThreads(__tstate);
41016 if (PyErr_Occurred()) SWIG_fail;
41017 }
41018 {
41019 resultobj = SWIG_From_int((int)(result));
41020 }
41021 return resultobj;
41022 fail:
41023 return NULL;
41024 }
41025
41026
41027 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41028 PyObject *resultobj;
41029 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41030 int result;
41031 PyObject * obj0 = 0 ;
41032 char *kwnames[] = {
41033 (char *) "self", NULL
41034 };
41035
41036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41038 if (SWIG_arg_fail(1)) SWIG_fail;
41039 {
41040 PyThreadState* __tstate = wxPyBeginAllowThreads();
41041 result = (int)(arg1)->GetRows();
41042
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 {
41047 resultobj = SWIG_From_int((int)(result));
41048 }
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj;
41057 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41058 int result;
41059 PyObject * obj0 = 0 ;
41060 char *kwnames[] = {
41061 (char *) "self", NULL
41062 };
41063
41064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41066 if (SWIG_arg_fail(1)) SWIG_fail;
41067 {
41068 PyThreadState* __tstate = wxPyBeginAllowThreads();
41069 result = (int)(arg1)->GetVGap();
41070
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 {
41075 resultobj = SWIG_From_int((int)(result));
41076 }
41077 return resultobj;
41078 fail:
41079 return NULL;
41080 }
41081
41082
41083 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41084 PyObject *resultobj;
41085 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41086 int result;
41087 PyObject * obj0 = 0 ;
41088 char *kwnames[] = {
41089 (char *) "self", NULL
41090 };
41091
41092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41094 if (SWIG_arg_fail(1)) SWIG_fail;
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 result = (int)(arg1)->GetHGap();
41098
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 {
41103 resultobj = SWIG_From_int((int)(result));
41104 }
41105 return resultobj;
41106 fail:
41107 return NULL;
41108 }
41109
41110
41111 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41112 PyObject *obj;
41113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41114 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41115 Py_INCREF(obj);
41116 return Py_BuildValue((char *)"");
41117 }
41118 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41119 PyObject *resultobj;
41120 int arg1 = (int) 1 ;
41121 int arg2 = (int) 0 ;
41122 int arg3 = (int) 0 ;
41123 int arg4 = (int) 0 ;
41124 wxFlexGridSizer *result;
41125 PyObject * obj0 = 0 ;
41126 PyObject * obj1 = 0 ;
41127 PyObject * obj2 = 0 ;
41128 PyObject * obj3 = 0 ;
41129 char *kwnames[] = {
41130 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41131 };
41132
41133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41134 if (obj0) {
41135 {
41136 arg1 = (int)(SWIG_As_int(obj0));
41137 if (SWIG_arg_fail(1)) SWIG_fail;
41138 }
41139 }
41140 if (obj1) {
41141 {
41142 arg2 = (int)(SWIG_As_int(obj1));
41143 if (SWIG_arg_fail(2)) SWIG_fail;
41144 }
41145 }
41146 if (obj2) {
41147 {
41148 arg3 = (int)(SWIG_As_int(obj2));
41149 if (SWIG_arg_fail(3)) SWIG_fail;
41150 }
41151 }
41152 if (obj3) {
41153 {
41154 arg4 = (int)(SWIG_As_int(obj3));
41155 if (SWIG_arg_fail(4)) SWIG_fail;
41156 }
41157 }
41158 {
41159 PyThreadState* __tstate = wxPyBeginAllowThreads();
41160 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41161
41162 wxPyEndAllowThreads(__tstate);
41163 if (PyErr_Occurred()) SWIG_fail;
41164 }
41165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41166 return resultobj;
41167 fail:
41168 return NULL;
41169 }
41170
41171
41172 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41173 PyObject *resultobj;
41174 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41175 size_t arg2 ;
41176 int arg3 = (int) 0 ;
41177 PyObject * obj0 = 0 ;
41178 PyObject * obj1 = 0 ;
41179 PyObject * obj2 = 0 ;
41180 char *kwnames[] = {
41181 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41182 };
41183
41184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41186 if (SWIG_arg_fail(1)) SWIG_fail;
41187 {
41188 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41189 if (SWIG_arg_fail(2)) SWIG_fail;
41190 }
41191 if (obj2) {
41192 {
41193 arg3 = (int)(SWIG_As_int(obj2));
41194 if (SWIG_arg_fail(3)) SWIG_fail;
41195 }
41196 }
41197 {
41198 PyThreadState* __tstate = wxPyBeginAllowThreads();
41199 (arg1)->AddGrowableRow(arg2,arg3);
41200
41201 wxPyEndAllowThreads(__tstate);
41202 if (PyErr_Occurred()) SWIG_fail;
41203 }
41204 Py_INCREF(Py_None); resultobj = Py_None;
41205 return resultobj;
41206 fail:
41207 return NULL;
41208 }
41209
41210
41211 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41212 PyObject *resultobj;
41213 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41214 size_t arg2 ;
41215 PyObject * obj0 = 0 ;
41216 PyObject * obj1 = 0 ;
41217 char *kwnames[] = {
41218 (char *) "self",(char *) "idx", NULL
41219 };
41220
41221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41223 if (SWIG_arg_fail(1)) SWIG_fail;
41224 {
41225 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41226 if (SWIG_arg_fail(2)) SWIG_fail;
41227 }
41228 {
41229 PyThreadState* __tstate = wxPyBeginAllowThreads();
41230 (arg1)->RemoveGrowableRow(arg2);
41231
41232 wxPyEndAllowThreads(__tstate);
41233 if (PyErr_Occurred()) SWIG_fail;
41234 }
41235 Py_INCREF(Py_None); resultobj = Py_None;
41236 return resultobj;
41237 fail:
41238 return NULL;
41239 }
41240
41241
41242 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41243 PyObject *resultobj;
41244 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41245 size_t arg2 ;
41246 int arg3 = (int) 0 ;
41247 PyObject * obj0 = 0 ;
41248 PyObject * obj1 = 0 ;
41249 PyObject * obj2 = 0 ;
41250 char *kwnames[] = {
41251 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41252 };
41253
41254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41256 if (SWIG_arg_fail(1)) SWIG_fail;
41257 {
41258 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41259 if (SWIG_arg_fail(2)) SWIG_fail;
41260 }
41261 if (obj2) {
41262 {
41263 arg3 = (int)(SWIG_As_int(obj2));
41264 if (SWIG_arg_fail(3)) SWIG_fail;
41265 }
41266 }
41267 {
41268 PyThreadState* __tstate = wxPyBeginAllowThreads();
41269 (arg1)->AddGrowableCol(arg2,arg3);
41270
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 Py_INCREF(Py_None); resultobj = Py_None;
41275 return resultobj;
41276 fail:
41277 return NULL;
41278 }
41279
41280
41281 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41282 PyObject *resultobj;
41283 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41284 size_t arg2 ;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 char *kwnames[] = {
41288 (char *) "self",(char *) "idx", NULL
41289 };
41290
41291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41293 if (SWIG_arg_fail(1)) SWIG_fail;
41294 {
41295 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41296 if (SWIG_arg_fail(2)) SWIG_fail;
41297 }
41298 {
41299 PyThreadState* __tstate = wxPyBeginAllowThreads();
41300 (arg1)->RemoveGrowableCol(arg2);
41301
41302 wxPyEndAllowThreads(__tstate);
41303 if (PyErr_Occurred()) SWIG_fail;
41304 }
41305 Py_INCREF(Py_None); resultobj = Py_None;
41306 return resultobj;
41307 fail:
41308 return NULL;
41309 }
41310
41311
41312 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41313 PyObject *resultobj;
41314 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41315 int arg2 ;
41316 PyObject * obj0 = 0 ;
41317 PyObject * obj1 = 0 ;
41318 char *kwnames[] = {
41319 (char *) "self",(char *) "direction", NULL
41320 };
41321
41322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41324 if (SWIG_arg_fail(1)) SWIG_fail;
41325 {
41326 arg2 = (int)(SWIG_As_int(obj1));
41327 if (SWIG_arg_fail(2)) SWIG_fail;
41328 }
41329 {
41330 PyThreadState* __tstate = wxPyBeginAllowThreads();
41331 (arg1)->SetFlexibleDirection(arg2);
41332
41333 wxPyEndAllowThreads(__tstate);
41334 if (PyErr_Occurred()) SWIG_fail;
41335 }
41336 Py_INCREF(Py_None); resultobj = Py_None;
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj;
41345 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41346 int result;
41347 PyObject * obj0 = 0 ;
41348 char *kwnames[] = {
41349 (char *) "self", NULL
41350 };
41351
41352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41354 if (SWIG_arg_fail(1)) SWIG_fail;
41355 {
41356 PyThreadState* __tstate = wxPyBeginAllowThreads();
41357 result = (int)(arg1)->GetFlexibleDirection();
41358
41359 wxPyEndAllowThreads(__tstate);
41360 if (PyErr_Occurred()) SWIG_fail;
41361 }
41362 {
41363 resultobj = SWIG_From_int((int)(result));
41364 }
41365 return resultobj;
41366 fail:
41367 return NULL;
41368 }
41369
41370
41371 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41372 PyObject *resultobj;
41373 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41374 wxFlexSizerGrowMode arg2 ;
41375 PyObject * obj0 = 0 ;
41376 PyObject * obj1 = 0 ;
41377 char *kwnames[] = {
41378 (char *) "self",(char *) "mode", NULL
41379 };
41380
41381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41383 if (SWIG_arg_fail(1)) SWIG_fail;
41384 {
41385 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41386 if (SWIG_arg_fail(2)) SWIG_fail;
41387 }
41388 {
41389 PyThreadState* __tstate = wxPyBeginAllowThreads();
41390 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41391
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 Py_INCREF(Py_None); resultobj = Py_None;
41396 return resultobj;
41397 fail:
41398 return NULL;
41399 }
41400
41401
41402 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41403 PyObject *resultobj;
41404 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41405 wxFlexSizerGrowMode result;
41406 PyObject * obj0 = 0 ;
41407 char *kwnames[] = {
41408 (char *) "self", NULL
41409 };
41410
41411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41413 if (SWIG_arg_fail(1)) SWIG_fail;
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41417
41418 wxPyEndAllowThreads(__tstate);
41419 if (PyErr_Occurred()) SWIG_fail;
41420 }
41421 resultobj = SWIG_From_int((result));
41422 return resultobj;
41423 fail:
41424 return NULL;
41425 }
41426
41427
41428 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41429 PyObject *resultobj;
41430 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41431 wxArrayInt *result;
41432 PyObject * obj0 = 0 ;
41433 char *kwnames[] = {
41434 (char *) "self", NULL
41435 };
41436
41437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41439 if (SWIG_arg_fail(1)) SWIG_fail;
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 {
41443 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41444 result = (wxArrayInt *) &_result_ref;
41445 }
41446
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 {
41451 resultobj = PyList_New(0);
41452 size_t idx;
41453 for (idx = 0; idx < result->GetCount(); idx += 1) {
41454 PyObject* val = PyInt_FromLong( result->Item(idx) );
41455 PyList_Append(resultobj, val);
41456 Py_DECREF(val);
41457 }
41458 }
41459 return resultobj;
41460 fail:
41461 return NULL;
41462 }
41463
41464
41465 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41466 PyObject *resultobj;
41467 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41468 wxArrayInt *result;
41469 PyObject * obj0 = 0 ;
41470 char *kwnames[] = {
41471 (char *) "self", NULL
41472 };
41473
41474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41476 if (SWIG_arg_fail(1)) SWIG_fail;
41477 {
41478 PyThreadState* __tstate = wxPyBeginAllowThreads();
41479 {
41480 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41481 result = (wxArrayInt *) &_result_ref;
41482 }
41483
41484 wxPyEndAllowThreads(__tstate);
41485 if (PyErr_Occurred()) SWIG_fail;
41486 }
41487 {
41488 resultobj = PyList_New(0);
41489 size_t idx;
41490 for (idx = 0; idx < result->GetCount(); idx += 1) {
41491 PyObject* val = PyInt_FromLong( result->Item(idx) );
41492 PyList_Append(resultobj, val);
41493 Py_DECREF(val);
41494 }
41495 }
41496 return resultobj;
41497 fail:
41498 return NULL;
41499 }
41500
41501
41502 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41503 PyObject *obj;
41504 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41505 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41506 Py_INCREF(obj);
41507 return Py_BuildValue((char *)"");
41508 }
41509 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41510 PyObject *resultobj;
41511 wxStdDialogButtonSizer *result;
41512 char *kwnames[] = {
41513 NULL
41514 };
41515
41516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41517 {
41518 PyThreadState* __tstate = wxPyBeginAllowThreads();
41519 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41520
41521 wxPyEndAllowThreads(__tstate);
41522 if (PyErr_Occurred()) SWIG_fail;
41523 }
41524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41525 return resultobj;
41526 fail:
41527 return NULL;
41528 }
41529
41530
41531 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41532 PyObject *resultobj;
41533 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41534 wxButton *arg2 = (wxButton *) 0 ;
41535 PyObject * obj0 = 0 ;
41536 PyObject * obj1 = 0 ;
41537 char *kwnames[] = {
41538 (char *) "self",(char *) "button", NULL
41539 };
41540
41541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41543 if (SWIG_arg_fail(1)) SWIG_fail;
41544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41545 if (SWIG_arg_fail(2)) SWIG_fail;
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 (arg1)->AddButton(arg2);
41549
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 Py_INCREF(Py_None); resultobj = Py_None;
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41561 PyObject *resultobj;
41562 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41563 PyObject * obj0 = 0 ;
41564 char *kwnames[] = {
41565 (char *) "self", NULL
41566 };
41567
41568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41570 if (SWIG_arg_fail(1)) SWIG_fail;
41571 {
41572 PyThreadState* __tstate = wxPyBeginAllowThreads();
41573 (arg1)->Realize();
41574
41575 wxPyEndAllowThreads(__tstate);
41576 if (PyErr_Occurred()) SWIG_fail;
41577 }
41578 Py_INCREF(Py_None); resultobj = Py_None;
41579 return resultobj;
41580 fail:
41581 return NULL;
41582 }
41583
41584
41585 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41586 PyObject *resultobj;
41587 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41588 wxButton *arg2 = (wxButton *) 0 ;
41589 PyObject * obj0 = 0 ;
41590 PyObject * obj1 = 0 ;
41591 char *kwnames[] = {
41592 (char *) "self",(char *) "button", NULL
41593 };
41594
41595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41597 if (SWIG_arg_fail(1)) SWIG_fail;
41598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41599 if (SWIG_arg_fail(2)) SWIG_fail;
41600 {
41601 PyThreadState* __tstate = wxPyBeginAllowThreads();
41602 (arg1)->SetAffirmativeButton(arg2);
41603
41604 wxPyEndAllowThreads(__tstate);
41605 if (PyErr_Occurred()) SWIG_fail;
41606 }
41607 Py_INCREF(Py_None); resultobj = Py_None;
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj;
41616 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41617 wxButton *arg2 = (wxButton *) 0 ;
41618 PyObject * obj0 = 0 ;
41619 PyObject * obj1 = 0 ;
41620 char *kwnames[] = {
41621 (char *) "self",(char *) "button", NULL
41622 };
41623
41624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41626 if (SWIG_arg_fail(1)) SWIG_fail;
41627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41628 if (SWIG_arg_fail(2)) SWIG_fail;
41629 {
41630 PyThreadState* __tstate = wxPyBeginAllowThreads();
41631 (arg1)->SetNegativeButton(arg2);
41632
41633 wxPyEndAllowThreads(__tstate);
41634 if (PyErr_Occurred()) SWIG_fail;
41635 }
41636 Py_INCREF(Py_None); resultobj = Py_None;
41637 return resultobj;
41638 fail:
41639 return NULL;
41640 }
41641
41642
41643 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41644 PyObject *resultobj;
41645 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41646 wxButton *arg2 = (wxButton *) 0 ;
41647 PyObject * obj0 = 0 ;
41648 PyObject * obj1 = 0 ;
41649 char *kwnames[] = {
41650 (char *) "self",(char *) "button", NULL
41651 };
41652
41653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41655 if (SWIG_arg_fail(1)) SWIG_fail;
41656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41657 if (SWIG_arg_fail(2)) SWIG_fail;
41658 {
41659 PyThreadState* __tstate = wxPyBeginAllowThreads();
41660 (arg1)->SetCancelButton(arg2);
41661
41662 wxPyEndAllowThreads(__tstate);
41663 if (PyErr_Occurred()) SWIG_fail;
41664 }
41665 Py_INCREF(Py_None); resultobj = Py_None;
41666 return resultobj;
41667 fail:
41668 return NULL;
41669 }
41670
41671
41672 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj;
41674 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41675 wxButton *result;
41676 PyObject * obj0 = 0 ;
41677 char *kwnames[] = {
41678 (char *) "self", NULL
41679 };
41680
41681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41683 if (SWIG_arg_fail(1)) SWIG_fail;
41684 {
41685 PyThreadState* __tstate = wxPyBeginAllowThreads();
41686 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41687
41688 wxPyEndAllowThreads(__tstate);
41689 if (PyErr_Occurred()) SWIG_fail;
41690 }
41691 {
41692 resultobj = wxPyMake_wxObject(result, 0);
41693 }
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj;
41702 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41703 wxButton *result;
41704 PyObject * obj0 = 0 ;
41705 char *kwnames[] = {
41706 (char *) "self", NULL
41707 };
41708
41709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41711 if (SWIG_arg_fail(1)) SWIG_fail;
41712 {
41713 PyThreadState* __tstate = wxPyBeginAllowThreads();
41714 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41715
41716 wxPyEndAllowThreads(__tstate);
41717 if (PyErr_Occurred()) SWIG_fail;
41718 }
41719 {
41720 resultobj = wxPyMake_wxObject(result, 0);
41721 }
41722 return resultobj;
41723 fail:
41724 return NULL;
41725 }
41726
41727
41728 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41729 PyObject *resultobj;
41730 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41731 wxButton *result;
41732 PyObject * obj0 = 0 ;
41733 char *kwnames[] = {
41734 (char *) "self", NULL
41735 };
41736
41737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41739 if (SWIG_arg_fail(1)) SWIG_fail;
41740 {
41741 PyThreadState* __tstate = wxPyBeginAllowThreads();
41742 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41743
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 {
41748 resultobj = wxPyMake_wxObject(result, 0);
41749 }
41750 return resultobj;
41751 fail:
41752 return NULL;
41753 }
41754
41755
41756 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41757 PyObject *resultobj;
41758 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41759 wxButton *result;
41760 PyObject * obj0 = 0 ;
41761 char *kwnames[] = {
41762 (char *) "self", NULL
41763 };
41764
41765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41767 if (SWIG_arg_fail(1)) SWIG_fail;
41768 {
41769 PyThreadState* __tstate = wxPyBeginAllowThreads();
41770 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41771
41772 wxPyEndAllowThreads(__tstate);
41773 if (PyErr_Occurred()) SWIG_fail;
41774 }
41775 {
41776 resultobj = wxPyMake_wxObject(result, 0);
41777 }
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41785 PyObject *resultobj;
41786 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41787 wxButton *result;
41788 PyObject * obj0 = 0 ;
41789 char *kwnames[] = {
41790 (char *) "self", NULL
41791 };
41792
41793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41795 if (SWIG_arg_fail(1)) SWIG_fail;
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41799
41800 wxPyEndAllowThreads(__tstate);
41801 if (PyErr_Occurred()) SWIG_fail;
41802 }
41803 {
41804 resultobj = wxPyMake_wxObject(result, 0);
41805 }
41806 return resultobj;
41807 fail:
41808 return NULL;
41809 }
41810
41811
41812 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41813 PyObject *obj;
41814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41815 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41816 Py_INCREF(obj);
41817 return Py_BuildValue((char *)"");
41818 }
41819 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41820 PyObject *resultobj;
41821 int arg1 = (int) 0 ;
41822 int arg2 = (int) 0 ;
41823 wxGBPosition *result;
41824 PyObject * obj0 = 0 ;
41825 PyObject * obj1 = 0 ;
41826 char *kwnames[] = {
41827 (char *) "row",(char *) "col", NULL
41828 };
41829
41830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41831 if (obj0) {
41832 {
41833 arg1 = (int)(SWIG_As_int(obj0));
41834 if (SWIG_arg_fail(1)) SWIG_fail;
41835 }
41836 }
41837 if (obj1) {
41838 {
41839 arg2 = (int)(SWIG_As_int(obj1));
41840 if (SWIG_arg_fail(2)) SWIG_fail;
41841 }
41842 }
41843 {
41844 PyThreadState* __tstate = wxPyBeginAllowThreads();
41845 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41846
41847 wxPyEndAllowThreads(__tstate);
41848 if (PyErr_Occurred()) SWIG_fail;
41849 }
41850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41851 return resultobj;
41852 fail:
41853 return NULL;
41854 }
41855
41856
41857 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41858 PyObject *resultobj;
41859 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41860 int result;
41861 PyObject * obj0 = 0 ;
41862 char *kwnames[] = {
41863 (char *) "self", NULL
41864 };
41865
41866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41868 if (SWIG_arg_fail(1)) SWIG_fail;
41869 {
41870 PyThreadState* __tstate = wxPyBeginAllowThreads();
41871 result = (int)((wxGBPosition const *)arg1)->GetRow();
41872
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 {
41877 resultobj = SWIG_From_int((int)(result));
41878 }
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj;
41887 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41888 int result;
41889 PyObject * obj0 = 0 ;
41890 char *kwnames[] = {
41891 (char *) "self", NULL
41892 };
41893
41894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41896 if (SWIG_arg_fail(1)) SWIG_fail;
41897 {
41898 PyThreadState* __tstate = wxPyBeginAllowThreads();
41899 result = (int)((wxGBPosition const *)arg1)->GetCol();
41900
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 resultobj = SWIG_From_int((int)(result));
41906 }
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj;
41915 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41916 int arg2 ;
41917 PyObject * obj0 = 0 ;
41918 PyObject * obj1 = 0 ;
41919 char *kwnames[] = {
41920 (char *) "self",(char *) "row", NULL
41921 };
41922
41923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41925 if (SWIG_arg_fail(1)) SWIG_fail;
41926 {
41927 arg2 = (int)(SWIG_As_int(obj1));
41928 if (SWIG_arg_fail(2)) SWIG_fail;
41929 }
41930 {
41931 PyThreadState* __tstate = wxPyBeginAllowThreads();
41932 (arg1)->SetRow(arg2);
41933
41934 wxPyEndAllowThreads(__tstate);
41935 if (PyErr_Occurred()) SWIG_fail;
41936 }
41937 Py_INCREF(Py_None); resultobj = Py_None;
41938 return resultobj;
41939 fail:
41940 return NULL;
41941 }
41942
41943
41944 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41945 PyObject *resultobj;
41946 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41947 int arg2 ;
41948 PyObject * obj0 = 0 ;
41949 PyObject * obj1 = 0 ;
41950 char *kwnames[] = {
41951 (char *) "self",(char *) "col", NULL
41952 };
41953
41954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41956 if (SWIG_arg_fail(1)) SWIG_fail;
41957 {
41958 arg2 = (int)(SWIG_As_int(obj1));
41959 if (SWIG_arg_fail(2)) SWIG_fail;
41960 }
41961 {
41962 PyThreadState* __tstate = wxPyBeginAllowThreads();
41963 (arg1)->SetCol(arg2);
41964
41965 wxPyEndAllowThreads(__tstate);
41966 if (PyErr_Occurred()) SWIG_fail;
41967 }
41968 Py_INCREF(Py_None); resultobj = Py_None;
41969 return resultobj;
41970 fail:
41971 return NULL;
41972 }
41973
41974
41975 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41976 PyObject *resultobj;
41977 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41978 wxGBPosition *arg2 = 0 ;
41979 bool result;
41980 wxGBPosition temp2 ;
41981 PyObject * obj0 = 0 ;
41982 PyObject * obj1 = 0 ;
41983 char *kwnames[] = {
41984 (char *) "self",(char *) "other", NULL
41985 };
41986
41987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41989 if (SWIG_arg_fail(1)) SWIG_fail;
41990 {
41991 arg2 = &temp2;
41992 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41993 }
41994 {
41995 PyThreadState* __tstate = wxPyBeginAllowThreads();
41996 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41997
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 {
42002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42003 }
42004 return resultobj;
42005 fail:
42006 return NULL;
42007 }
42008
42009
42010 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42011 PyObject *resultobj;
42012 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42013 wxGBPosition *arg2 = 0 ;
42014 bool result;
42015 wxGBPosition temp2 ;
42016 PyObject * obj0 = 0 ;
42017 PyObject * obj1 = 0 ;
42018 char *kwnames[] = {
42019 (char *) "self",(char *) "other", NULL
42020 };
42021
42022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42024 if (SWIG_arg_fail(1)) SWIG_fail;
42025 {
42026 arg2 = &temp2;
42027 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42028 }
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42032
42033 wxPyEndAllowThreads(__tstate);
42034 if (PyErr_Occurred()) SWIG_fail;
42035 }
42036 {
42037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42038 }
42039 return resultobj;
42040 fail:
42041 return NULL;
42042 }
42043
42044
42045 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42046 PyObject *resultobj;
42047 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42048 int arg2 = (int) 0 ;
42049 int arg3 = (int) 0 ;
42050 PyObject * obj0 = 0 ;
42051 PyObject * obj1 = 0 ;
42052 PyObject * obj2 = 0 ;
42053 char *kwnames[] = {
42054 (char *) "self",(char *) "row",(char *) "col", NULL
42055 };
42056
42057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42059 if (SWIG_arg_fail(1)) SWIG_fail;
42060 if (obj1) {
42061 {
42062 arg2 = (int)(SWIG_As_int(obj1));
42063 if (SWIG_arg_fail(2)) SWIG_fail;
42064 }
42065 }
42066 if (obj2) {
42067 {
42068 arg3 = (int)(SWIG_As_int(obj2));
42069 if (SWIG_arg_fail(3)) SWIG_fail;
42070 }
42071 }
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 wxGBPosition_Set(arg1,arg2,arg3);
42075
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 Py_INCREF(Py_None); resultobj = Py_None;
42080 return resultobj;
42081 fail:
42082 return NULL;
42083 }
42084
42085
42086 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42087 PyObject *resultobj;
42088 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42089 PyObject *result;
42090 PyObject * obj0 = 0 ;
42091 char *kwnames[] = {
42092 (char *) "self", NULL
42093 };
42094
42095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42097 if (SWIG_arg_fail(1)) SWIG_fail;
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 result = (PyObject *)wxGBPosition_Get(arg1);
42101
42102 wxPyEndAllowThreads(__tstate);
42103 if (PyErr_Occurred()) SWIG_fail;
42104 }
42105 resultobj = result;
42106 return resultobj;
42107 fail:
42108 return NULL;
42109 }
42110
42111
42112 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42113 PyObject *obj;
42114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42115 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42116 Py_INCREF(obj);
42117 return Py_BuildValue((char *)"");
42118 }
42119 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42120 PyObject *resultobj;
42121 int arg1 = (int) 1 ;
42122 int arg2 = (int) 1 ;
42123 wxGBSpan *result;
42124 PyObject * obj0 = 0 ;
42125 PyObject * obj1 = 0 ;
42126 char *kwnames[] = {
42127 (char *) "rowspan",(char *) "colspan", NULL
42128 };
42129
42130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42131 if (obj0) {
42132 {
42133 arg1 = (int)(SWIG_As_int(obj0));
42134 if (SWIG_arg_fail(1)) SWIG_fail;
42135 }
42136 }
42137 if (obj1) {
42138 {
42139 arg2 = (int)(SWIG_As_int(obj1));
42140 if (SWIG_arg_fail(2)) SWIG_fail;
42141 }
42142 }
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42146
42147 wxPyEndAllowThreads(__tstate);
42148 if (PyErr_Occurred()) SWIG_fail;
42149 }
42150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj;
42159 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42160 int result;
42161 PyObject * obj0 = 0 ;
42162 char *kwnames[] = {
42163 (char *) "self", NULL
42164 };
42165
42166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42168 if (SWIG_arg_fail(1)) SWIG_fail;
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42172
42173 wxPyEndAllowThreads(__tstate);
42174 if (PyErr_Occurred()) SWIG_fail;
42175 }
42176 {
42177 resultobj = SWIG_From_int((int)(result));
42178 }
42179 return resultobj;
42180 fail:
42181 return NULL;
42182 }
42183
42184
42185 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42186 PyObject *resultobj;
42187 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42188 int result;
42189 PyObject * obj0 = 0 ;
42190 char *kwnames[] = {
42191 (char *) "self", NULL
42192 };
42193
42194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42196 if (SWIG_arg_fail(1)) SWIG_fail;
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42200
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 {
42205 resultobj = SWIG_From_int((int)(result));
42206 }
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj;
42215 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42216 int arg2 ;
42217 PyObject * obj0 = 0 ;
42218 PyObject * obj1 = 0 ;
42219 char *kwnames[] = {
42220 (char *) "self",(char *) "rowspan", NULL
42221 };
42222
42223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42225 if (SWIG_arg_fail(1)) SWIG_fail;
42226 {
42227 arg2 = (int)(SWIG_As_int(obj1));
42228 if (SWIG_arg_fail(2)) SWIG_fail;
42229 }
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 (arg1)->SetRowspan(arg2);
42233
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 Py_INCREF(Py_None); resultobj = Py_None;
42238 return resultobj;
42239 fail:
42240 return NULL;
42241 }
42242
42243
42244 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42245 PyObject *resultobj;
42246 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42247 int arg2 ;
42248 PyObject * obj0 = 0 ;
42249 PyObject * obj1 = 0 ;
42250 char *kwnames[] = {
42251 (char *) "self",(char *) "colspan", NULL
42252 };
42253
42254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42256 if (SWIG_arg_fail(1)) SWIG_fail;
42257 {
42258 arg2 = (int)(SWIG_As_int(obj1));
42259 if (SWIG_arg_fail(2)) SWIG_fail;
42260 }
42261 {
42262 PyThreadState* __tstate = wxPyBeginAllowThreads();
42263 (arg1)->SetColspan(arg2);
42264
42265 wxPyEndAllowThreads(__tstate);
42266 if (PyErr_Occurred()) SWIG_fail;
42267 }
42268 Py_INCREF(Py_None); resultobj = Py_None;
42269 return resultobj;
42270 fail:
42271 return NULL;
42272 }
42273
42274
42275 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42276 PyObject *resultobj;
42277 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42278 wxGBSpan *arg2 = 0 ;
42279 bool result;
42280 wxGBSpan temp2 ;
42281 PyObject * obj0 = 0 ;
42282 PyObject * obj1 = 0 ;
42283 char *kwnames[] = {
42284 (char *) "self",(char *) "other", NULL
42285 };
42286
42287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42289 if (SWIG_arg_fail(1)) SWIG_fail;
42290 {
42291 arg2 = &temp2;
42292 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42293 }
42294 {
42295 PyThreadState* __tstate = wxPyBeginAllowThreads();
42296 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42297
42298 wxPyEndAllowThreads(__tstate);
42299 if (PyErr_Occurred()) SWIG_fail;
42300 }
42301 {
42302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42303 }
42304 return resultobj;
42305 fail:
42306 return NULL;
42307 }
42308
42309
42310 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42311 PyObject *resultobj;
42312 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42313 wxGBSpan *arg2 = 0 ;
42314 bool result;
42315 wxGBSpan temp2 ;
42316 PyObject * obj0 = 0 ;
42317 PyObject * obj1 = 0 ;
42318 char *kwnames[] = {
42319 (char *) "self",(char *) "other", NULL
42320 };
42321
42322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42324 if (SWIG_arg_fail(1)) SWIG_fail;
42325 {
42326 arg2 = &temp2;
42327 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42328 }
42329 {
42330 PyThreadState* __tstate = wxPyBeginAllowThreads();
42331 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42332
42333 wxPyEndAllowThreads(__tstate);
42334 if (PyErr_Occurred()) SWIG_fail;
42335 }
42336 {
42337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42338 }
42339 return resultobj;
42340 fail:
42341 return NULL;
42342 }
42343
42344
42345 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42346 PyObject *resultobj;
42347 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42348 int arg2 = (int) 1 ;
42349 int arg3 = (int) 1 ;
42350 PyObject * obj0 = 0 ;
42351 PyObject * obj1 = 0 ;
42352 PyObject * obj2 = 0 ;
42353 char *kwnames[] = {
42354 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42355 };
42356
42357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42359 if (SWIG_arg_fail(1)) SWIG_fail;
42360 if (obj1) {
42361 {
42362 arg2 = (int)(SWIG_As_int(obj1));
42363 if (SWIG_arg_fail(2)) SWIG_fail;
42364 }
42365 }
42366 if (obj2) {
42367 {
42368 arg3 = (int)(SWIG_As_int(obj2));
42369 if (SWIG_arg_fail(3)) SWIG_fail;
42370 }
42371 }
42372 {
42373 PyThreadState* __tstate = wxPyBeginAllowThreads();
42374 wxGBSpan_Set(arg1,arg2,arg3);
42375
42376 wxPyEndAllowThreads(__tstate);
42377 if (PyErr_Occurred()) SWIG_fail;
42378 }
42379 Py_INCREF(Py_None); resultobj = Py_None;
42380 return resultobj;
42381 fail:
42382 return NULL;
42383 }
42384
42385
42386 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42387 PyObject *resultobj;
42388 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42389 PyObject *result;
42390 PyObject * obj0 = 0 ;
42391 char *kwnames[] = {
42392 (char *) "self", NULL
42393 };
42394
42395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42397 if (SWIG_arg_fail(1)) SWIG_fail;
42398 {
42399 PyThreadState* __tstate = wxPyBeginAllowThreads();
42400 result = (PyObject *)wxGBSpan_Get(arg1);
42401
42402 wxPyEndAllowThreads(__tstate);
42403 if (PyErr_Occurred()) SWIG_fail;
42404 }
42405 resultobj = result;
42406 return resultobj;
42407 fail:
42408 return NULL;
42409 }
42410
42411
42412 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42413 PyObject *obj;
42414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42415 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42416 Py_INCREF(obj);
42417 return Py_BuildValue((char *)"");
42418 }
42419 static int _wrap_DefaultSpan_set(PyObject *) {
42420 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42421 return 1;
42422 }
42423
42424
42425 static PyObject *_wrap_DefaultSpan_get(void) {
42426 PyObject *pyobj;
42427
42428 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42429 return pyobj;
42430 }
42431
42432
42433 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42434 PyObject *resultobj;
42435 wxGBSizerItem *result;
42436 char *kwnames[] = {
42437 NULL
42438 };
42439
42440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42441 {
42442 PyThreadState* __tstate = wxPyBeginAllowThreads();
42443 result = (wxGBSizerItem *)new wxGBSizerItem();
42444
42445 wxPyEndAllowThreads(__tstate);
42446 if (PyErr_Occurred()) SWIG_fail;
42447 }
42448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42449 return resultobj;
42450 fail:
42451 return NULL;
42452 }
42453
42454
42455 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42456 PyObject *resultobj;
42457 wxWindow *arg1 = (wxWindow *) 0 ;
42458 wxGBPosition *arg2 = 0 ;
42459 wxGBSpan *arg3 = 0 ;
42460 int arg4 ;
42461 int arg5 ;
42462 PyObject *arg6 = (PyObject *) NULL ;
42463 wxGBSizerItem *result;
42464 wxGBPosition temp2 ;
42465 wxGBSpan temp3 ;
42466 PyObject * obj0 = 0 ;
42467 PyObject * obj1 = 0 ;
42468 PyObject * obj2 = 0 ;
42469 PyObject * obj3 = 0 ;
42470 PyObject * obj4 = 0 ;
42471 PyObject * obj5 = 0 ;
42472 char *kwnames[] = {
42473 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42474 };
42475
42476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42478 if (SWIG_arg_fail(1)) SWIG_fail;
42479 {
42480 arg2 = &temp2;
42481 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42482 }
42483 {
42484 arg3 = &temp3;
42485 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42486 }
42487 {
42488 arg4 = (int)(SWIG_As_int(obj3));
42489 if (SWIG_arg_fail(4)) SWIG_fail;
42490 }
42491 {
42492 arg5 = (int)(SWIG_As_int(obj4));
42493 if (SWIG_arg_fail(5)) SWIG_fail;
42494 }
42495 if (obj5) {
42496 arg6 = obj5;
42497 }
42498 {
42499 PyThreadState* __tstate = wxPyBeginAllowThreads();
42500 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42501
42502 wxPyEndAllowThreads(__tstate);
42503 if (PyErr_Occurred()) SWIG_fail;
42504 }
42505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42506 return resultobj;
42507 fail:
42508 return NULL;
42509 }
42510
42511
42512 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42513 PyObject *resultobj;
42514 wxSizer *arg1 = (wxSizer *) 0 ;
42515 wxGBPosition *arg2 = 0 ;
42516 wxGBSpan *arg3 = 0 ;
42517 int arg4 ;
42518 int arg5 ;
42519 PyObject *arg6 = (PyObject *) NULL ;
42520 wxGBSizerItem *result;
42521 wxGBPosition temp2 ;
42522 wxGBSpan temp3 ;
42523 PyObject * obj0 = 0 ;
42524 PyObject * obj1 = 0 ;
42525 PyObject * obj2 = 0 ;
42526 PyObject * obj3 = 0 ;
42527 PyObject * obj4 = 0 ;
42528 PyObject * obj5 = 0 ;
42529 char *kwnames[] = {
42530 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42531 };
42532
42533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42535 if (SWIG_arg_fail(1)) SWIG_fail;
42536 {
42537 arg2 = &temp2;
42538 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42539 }
42540 {
42541 arg3 = &temp3;
42542 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42543 }
42544 {
42545 arg4 = (int)(SWIG_As_int(obj3));
42546 if (SWIG_arg_fail(4)) SWIG_fail;
42547 }
42548 {
42549 arg5 = (int)(SWIG_As_int(obj4));
42550 if (SWIG_arg_fail(5)) SWIG_fail;
42551 }
42552 if (obj5) {
42553 arg6 = obj5;
42554 }
42555 {
42556 PyThreadState* __tstate = wxPyBeginAllowThreads();
42557 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42558
42559 wxPyEndAllowThreads(__tstate);
42560 if (PyErr_Occurred()) SWIG_fail;
42561 }
42562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42563 return resultobj;
42564 fail:
42565 return NULL;
42566 }
42567
42568
42569 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42570 PyObject *resultobj;
42571 int arg1 ;
42572 int arg2 ;
42573 wxGBPosition *arg3 = 0 ;
42574 wxGBSpan *arg4 = 0 ;
42575 int arg5 ;
42576 int arg6 ;
42577 PyObject *arg7 = (PyObject *) NULL ;
42578 wxGBSizerItem *result;
42579 wxGBPosition temp3 ;
42580 wxGBSpan temp4 ;
42581 PyObject * obj0 = 0 ;
42582 PyObject * obj1 = 0 ;
42583 PyObject * obj2 = 0 ;
42584 PyObject * obj3 = 0 ;
42585 PyObject * obj4 = 0 ;
42586 PyObject * obj5 = 0 ;
42587 PyObject * obj6 = 0 ;
42588 char *kwnames[] = {
42589 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42590 };
42591
42592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42593 {
42594 arg1 = (int)(SWIG_As_int(obj0));
42595 if (SWIG_arg_fail(1)) SWIG_fail;
42596 }
42597 {
42598 arg2 = (int)(SWIG_As_int(obj1));
42599 if (SWIG_arg_fail(2)) SWIG_fail;
42600 }
42601 {
42602 arg3 = &temp3;
42603 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42604 }
42605 {
42606 arg4 = &temp4;
42607 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42608 }
42609 {
42610 arg5 = (int)(SWIG_As_int(obj4));
42611 if (SWIG_arg_fail(5)) SWIG_fail;
42612 }
42613 {
42614 arg6 = (int)(SWIG_As_int(obj5));
42615 if (SWIG_arg_fail(6)) SWIG_fail;
42616 }
42617 if (obj6) {
42618 arg7 = obj6;
42619 }
42620 {
42621 PyThreadState* __tstate = wxPyBeginAllowThreads();
42622 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42623
42624 wxPyEndAllowThreads(__tstate);
42625 if (PyErr_Occurred()) SWIG_fail;
42626 }
42627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42628 return resultobj;
42629 fail:
42630 return NULL;
42631 }
42632
42633
42634 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42635 PyObject *resultobj;
42636 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42637 wxGBPosition result;
42638 PyObject * obj0 = 0 ;
42639 char *kwnames[] = {
42640 (char *) "self", NULL
42641 };
42642
42643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42645 if (SWIG_arg_fail(1)) SWIG_fail;
42646 {
42647 PyThreadState* __tstate = wxPyBeginAllowThreads();
42648 result = ((wxGBSizerItem const *)arg1)->GetPos();
42649
42650 wxPyEndAllowThreads(__tstate);
42651 if (PyErr_Occurred()) SWIG_fail;
42652 }
42653 {
42654 wxGBPosition * resultptr;
42655 resultptr = new wxGBPosition((wxGBPosition &)(result));
42656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42657 }
42658 return resultobj;
42659 fail:
42660 return NULL;
42661 }
42662
42663
42664 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42665 PyObject *resultobj;
42666 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42667 wxGBSpan result;
42668 PyObject * obj0 = 0 ;
42669 char *kwnames[] = {
42670 (char *) "self", NULL
42671 };
42672
42673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42675 if (SWIG_arg_fail(1)) SWIG_fail;
42676 {
42677 PyThreadState* __tstate = wxPyBeginAllowThreads();
42678 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42679
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 {
42684 wxGBSpan * resultptr;
42685 resultptr = new wxGBSpan((wxGBSpan &)(result));
42686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42687 }
42688 return resultobj;
42689 fail:
42690 return NULL;
42691 }
42692
42693
42694 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42695 PyObject *resultobj;
42696 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42697 wxGBPosition *arg2 = 0 ;
42698 bool result;
42699 wxGBPosition temp2 ;
42700 PyObject * obj0 = 0 ;
42701 PyObject * obj1 = 0 ;
42702 char *kwnames[] = {
42703 (char *) "self",(char *) "pos", NULL
42704 };
42705
42706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42708 if (SWIG_arg_fail(1)) SWIG_fail;
42709 {
42710 arg2 = &temp2;
42711 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42712 }
42713 {
42714 PyThreadState* __tstate = wxPyBeginAllowThreads();
42715 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42716
42717 wxPyEndAllowThreads(__tstate);
42718 if (PyErr_Occurred()) SWIG_fail;
42719 }
42720 {
42721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42722 }
42723 return resultobj;
42724 fail:
42725 return NULL;
42726 }
42727
42728
42729 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42730 PyObject *resultobj;
42731 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42732 wxGBSpan *arg2 = 0 ;
42733 bool result;
42734 wxGBSpan temp2 ;
42735 PyObject * obj0 = 0 ;
42736 PyObject * obj1 = 0 ;
42737 char *kwnames[] = {
42738 (char *) "self",(char *) "span", NULL
42739 };
42740
42741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42743 if (SWIG_arg_fail(1)) SWIG_fail;
42744 {
42745 arg2 = &temp2;
42746 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42747 }
42748 {
42749 PyThreadState* __tstate = wxPyBeginAllowThreads();
42750 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42751
42752 wxPyEndAllowThreads(__tstate);
42753 if (PyErr_Occurred()) SWIG_fail;
42754 }
42755 {
42756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42757 }
42758 return resultobj;
42759 fail:
42760 return NULL;
42761 }
42762
42763
42764 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42765 PyObject *resultobj;
42766 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42767 wxGBSizerItem *arg2 = 0 ;
42768 bool result;
42769 PyObject * obj0 = 0 ;
42770 PyObject * obj1 = 0 ;
42771 char *kwnames[] = {
42772 (char *) "self",(char *) "other", NULL
42773 };
42774
42775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42777 if (SWIG_arg_fail(1)) SWIG_fail;
42778 {
42779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42780 if (SWIG_arg_fail(2)) SWIG_fail;
42781 if (arg2 == NULL) {
42782 SWIG_null_ref("wxGBSizerItem");
42783 }
42784 if (SWIG_arg_fail(2)) SWIG_fail;
42785 }
42786 {
42787 PyThreadState* __tstate = wxPyBeginAllowThreads();
42788 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42789
42790 wxPyEndAllowThreads(__tstate);
42791 if (PyErr_Occurred()) SWIG_fail;
42792 }
42793 {
42794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42795 }
42796 return resultobj;
42797 fail:
42798 return NULL;
42799 }
42800
42801
42802 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42803 PyObject *resultobj;
42804 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42805 wxGBPosition *arg2 = 0 ;
42806 wxGBSpan *arg3 = 0 ;
42807 bool result;
42808 wxGBPosition temp2 ;
42809 wxGBSpan temp3 ;
42810 PyObject * obj0 = 0 ;
42811 PyObject * obj1 = 0 ;
42812 PyObject * obj2 = 0 ;
42813 char *kwnames[] = {
42814 (char *) "self",(char *) "pos",(char *) "span", NULL
42815 };
42816
42817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42819 if (SWIG_arg_fail(1)) SWIG_fail;
42820 {
42821 arg2 = &temp2;
42822 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42823 }
42824 {
42825 arg3 = &temp3;
42826 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42827 }
42828 {
42829 PyThreadState* __tstate = wxPyBeginAllowThreads();
42830 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42831
42832 wxPyEndAllowThreads(__tstate);
42833 if (PyErr_Occurred()) SWIG_fail;
42834 }
42835 {
42836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42837 }
42838 return resultobj;
42839 fail:
42840 return NULL;
42841 }
42842
42843
42844 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42845 PyObject *resultobj;
42846 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42847 wxGBPosition result;
42848 PyObject * obj0 = 0 ;
42849 char *kwnames[] = {
42850 (char *) "self", NULL
42851 };
42852
42853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42855 if (SWIG_arg_fail(1)) SWIG_fail;
42856 {
42857 PyThreadState* __tstate = wxPyBeginAllowThreads();
42858 result = wxGBSizerItem_GetEndPos(arg1);
42859
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 {
42864 wxGBPosition * resultptr;
42865 resultptr = new wxGBPosition((wxGBPosition &)(result));
42866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42867 }
42868 return resultobj;
42869 fail:
42870 return NULL;
42871 }
42872
42873
42874 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42875 PyObject *resultobj;
42876 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42877 wxGridBagSizer *result;
42878 PyObject * obj0 = 0 ;
42879 char *kwnames[] = {
42880 (char *) "self", NULL
42881 };
42882
42883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42885 if (SWIG_arg_fail(1)) SWIG_fail;
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42889
42890 wxPyEndAllowThreads(__tstate);
42891 if (PyErr_Occurred()) SWIG_fail;
42892 }
42893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42894 return resultobj;
42895 fail:
42896 return NULL;
42897 }
42898
42899
42900 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42901 PyObject *resultobj;
42902 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42903 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42904 PyObject * obj0 = 0 ;
42905 PyObject * obj1 = 0 ;
42906 char *kwnames[] = {
42907 (char *) "self",(char *) "sizer", NULL
42908 };
42909
42910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42912 if (SWIG_arg_fail(1)) SWIG_fail;
42913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42914 if (SWIG_arg_fail(2)) SWIG_fail;
42915 {
42916 PyThreadState* __tstate = wxPyBeginAllowThreads();
42917 (arg1)->SetGBSizer(arg2);
42918
42919 wxPyEndAllowThreads(__tstate);
42920 if (PyErr_Occurred()) SWIG_fail;
42921 }
42922 Py_INCREF(Py_None); resultobj = Py_None;
42923 return resultobj;
42924 fail:
42925 return NULL;
42926 }
42927
42928
42929 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42930 PyObject *obj;
42931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42932 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42933 Py_INCREF(obj);
42934 return Py_BuildValue((char *)"");
42935 }
42936 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42937 PyObject *resultobj;
42938 int arg1 = (int) 0 ;
42939 int arg2 = (int) 0 ;
42940 wxGridBagSizer *result;
42941 PyObject * obj0 = 0 ;
42942 PyObject * obj1 = 0 ;
42943 char *kwnames[] = {
42944 (char *) "vgap",(char *) "hgap", NULL
42945 };
42946
42947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42948 if (obj0) {
42949 {
42950 arg1 = (int)(SWIG_As_int(obj0));
42951 if (SWIG_arg_fail(1)) SWIG_fail;
42952 }
42953 }
42954 if (obj1) {
42955 {
42956 arg2 = (int)(SWIG_As_int(obj1));
42957 if (SWIG_arg_fail(2)) SWIG_fail;
42958 }
42959 }
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42963
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42968 return resultobj;
42969 fail:
42970 return NULL;
42971 }
42972
42973
42974 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj;
42976 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42977 PyObject *arg2 = (PyObject *) 0 ;
42978 wxGBPosition *arg3 = 0 ;
42979 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42980 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42981 int arg5 = (int) 0 ;
42982 int arg6 = (int) 0 ;
42983 PyObject *arg7 = (PyObject *) NULL ;
42984 wxGBSizerItem *result;
42985 wxGBPosition temp3 ;
42986 wxGBSpan temp4 ;
42987 PyObject * obj0 = 0 ;
42988 PyObject * obj1 = 0 ;
42989 PyObject * obj2 = 0 ;
42990 PyObject * obj3 = 0 ;
42991 PyObject * obj4 = 0 ;
42992 PyObject * obj5 = 0 ;
42993 PyObject * obj6 = 0 ;
42994 char *kwnames[] = {
42995 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42996 };
42997
42998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43000 if (SWIG_arg_fail(1)) SWIG_fail;
43001 arg2 = obj1;
43002 {
43003 arg3 = &temp3;
43004 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43005 }
43006 if (obj3) {
43007 {
43008 arg4 = &temp4;
43009 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43010 }
43011 }
43012 if (obj4) {
43013 {
43014 arg5 = (int)(SWIG_As_int(obj4));
43015 if (SWIG_arg_fail(5)) SWIG_fail;
43016 }
43017 }
43018 if (obj5) {
43019 {
43020 arg6 = (int)(SWIG_As_int(obj5));
43021 if (SWIG_arg_fail(6)) SWIG_fail;
43022 }
43023 }
43024 if (obj6) {
43025 arg7 = obj6;
43026 }
43027 {
43028 PyThreadState* __tstate = wxPyBeginAllowThreads();
43029 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43030
43031 wxPyEndAllowThreads(__tstate);
43032 if (PyErr_Occurred()) SWIG_fail;
43033 }
43034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43035 return resultobj;
43036 fail:
43037 return NULL;
43038 }
43039
43040
43041 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43042 PyObject *resultobj;
43043 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43044 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43045 wxGBSizerItem *result;
43046 PyObject * obj0 = 0 ;
43047 PyObject * obj1 = 0 ;
43048 char *kwnames[] = {
43049 (char *) "self",(char *) "item", NULL
43050 };
43051
43052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43054 if (SWIG_arg_fail(1)) SWIG_fail;
43055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43056 if (SWIG_arg_fail(2)) SWIG_fail;
43057 {
43058 PyThreadState* __tstate = wxPyBeginAllowThreads();
43059 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43060
43061 wxPyEndAllowThreads(__tstate);
43062 if (PyErr_Occurred()) SWIG_fail;
43063 }
43064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43065 return resultobj;
43066 fail:
43067 return NULL;
43068 }
43069
43070
43071 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43072 PyObject *resultobj;
43073 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43074 int arg2 ;
43075 int arg3 ;
43076 wxSize result;
43077 PyObject * obj0 = 0 ;
43078 PyObject * obj1 = 0 ;
43079 PyObject * obj2 = 0 ;
43080 char *kwnames[] = {
43081 (char *) "self",(char *) "row",(char *) "col", NULL
43082 };
43083
43084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43086 if (SWIG_arg_fail(1)) SWIG_fail;
43087 {
43088 arg2 = (int)(SWIG_As_int(obj1));
43089 if (SWIG_arg_fail(2)) SWIG_fail;
43090 }
43091 {
43092 arg3 = (int)(SWIG_As_int(obj2));
43093 if (SWIG_arg_fail(3)) SWIG_fail;
43094 }
43095 {
43096 PyThreadState* __tstate = wxPyBeginAllowThreads();
43097 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43098
43099 wxPyEndAllowThreads(__tstate);
43100 if (PyErr_Occurred()) SWIG_fail;
43101 }
43102 {
43103 wxSize * resultptr;
43104 resultptr = new wxSize((wxSize &)(result));
43105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43106 }
43107 return resultobj;
43108 fail:
43109 return NULL;
43110 }
43111
43112
43113 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43114 PyObject *resultobj;
43115 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43116 wxSize result;
43117 PyObject * obj0 = 0 ;
43118 char *kwnames[] = {
43119 (char *) "self", NULL
43120 };
43121
43122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43124 if (SWIG_arg_fail(1)) SWIG_fail;
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43128
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 {
43133 wxSize * resultptr;
43134 resultptr = new wxSize((wxSize &)(result));
43135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43136 }
43137 return resultobj;
43138 fail:
43139 return NULL;
43140 }
43141
43142
43143 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43144 PyObject *resultobj;
43145 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43146 wxSize *arg2 = 0 ;
43147 wxSize temp2 ;
43148 PyObject * obj0 = 0 ;
43149 PyObject * obj1 = 0 ;
43150 char *kwnames[] = {
43151 (char *) "self",(char *) "sz", NULL
43152 };
43153
43154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43156 if (SWIG_arg_fail(1)) SWIG_fail;
43157 {
43158 arg2 = &temp2;
43159 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43160 }
43161 {
43162 PyThreadState* __tstate = wxPyBeginAllowThreads();
43163 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43164
43165 wxPyEndAllowThreads(__tstate);
43166 if (PyErr_Occurred()) SWIG_fail;
43167 }
43168 Py_INCREF(Py_None); resultobj = Py_None;
43169 return resultobj;
43170 fail:
43171 return NULL;
43172 }
43173
43174
43175 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43176 PyObject *resultobj;
43177 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43178 wxWindow *arg2 = (wxWindow *) 0 ;
43179 wxGBPosition result;
43180 PyObject * obj0 = 0 ;
43181 PyObject * obj1 = 0 ;
43182
43183 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43185 if (SWIG_arg_fail(1)) SWIG_fail;
43186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43187 if (SWIG_arg_fail(2)) SWIG_fail;
43188 {
43189 PyThreadState* __tstate = wxPyBeginAllowThreads();
43190 result = (arg1)->GetItemPosition(arg2);
43191
43192 wxPyEndAllowThreads(__tstate);
43193 if (PyErr_Occurred()) SWIG_fail;
43194 }
43195 {
43196 wxGBPosition * resultptr;
43197 resultptr = new wxGBPosition((wxGBPosition &)(result));
43198 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43199 }
43200 return resultobj;
43201 fail:
43202 return NULL;
43203 }
43204
43205
43206 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43207 PyObject *resultobj;
43208 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43209 wxSizer *arg2 = (wxSizer *) 0 ;
43210 wxGBPosition result;
43211 PyObject * obj0 = 0 ;
43212 PyObject * obj1 = 0 ;
43213
43214 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43216 if (SWIG_arg_fail(1)) SWIG_fail;
43217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43218 if (SWIG_arg_fail(2)) SWIG_fail;
43219 {
43220 PyThreadState* __tstate = wxPyBeginAllowThreads();
43221 result = (arg1)->GetItemPosition(arg2);
43222
43223 wxPyEndAllowThreads(__tstate);
43224 if (PyErr_Occurred()) SWIG_fail;
43225 }
43226 {
43227 wxGBPosition * resultptr;
43228 resultptr = new wxGBPosition((wxGBPosition &)(result));
43229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43230 }
43231 return resultobj;
43232 fail:
43233 return NULL;
43234 }
43235
43236
43237 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43238 PyObject *resultobj;
43239 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43240 size_t arg2 ;
43241 wxGBPosition result;
43242 PyObject * obj0 = 0 ;
43243 PyObject * obj1 = 0 ;
43244
43245 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43247 if (SWIG_arg_fail(1)) SWIG_fail;
43248 {
43249 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43250 if (SWIG_arg_fail(2)) SWIG_fail;
43251 }
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 result = (arg1)->GetItemPosition(arg2);
43255
43256 wxPyEndAllowThreads(__tstate);
43257 if (PyErr_Occurred()) SWIG_fail;
43258 }
43259 {
43260 wxGBPosition * resultptr;
43261 resultptr = new wxGBPosition((wxGBPosition &)(result));
43262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43263 }
43264 return resultobj;
43265 fail:
43266 return NULL;
43267 }
43268
43269
43270 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43271 int argc;
43272 PyObject *argv[3];
43273 int ii;
43274
43275 argc = PyObject_Length(args);
43276 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43277 argv[ii] = PyTuple_GetItem(args,ii);
43278 }
43279 if (argc == 2) {
43280 int _v;
43281 {
43282 void *ptr;
43283 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43284 _v = 0;
43285 PyErr_Clear();
43286 } else {
43287 _v = 1;
43288 }
43289 }
43290 if (_v) {
43291 {
43292 void *ptr;
43293 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43294 _v = 0;
43295 PyErr_Clear();
43296 } else {
43297 _v = 1;
43298 }
43299 }
43300 if (_v) {
43301 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43302 }
43303 }
43304 }
43305 if (argc == 2) {
43306 int _v;
43307 {
43308 void *ptr;
43309 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43310 _v = 0;
43311 PyErr_Clear();
43312 } else {
43313 _v = 1;
43314 }
43315 }
43316 if (_v) {
43317 {
43318 void *ptr;
43319 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43320 _v = 0;
43321 PyErr_Clear();
43322 } else {
43323 _v = 1;
43324 }
43325 }
43326 if (_v) {
43327 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43328 }
43329 }
43330 }
43331 if (argc == 2) {
43332 int _v;
43333 {
43334 void *ptr;
43335 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43336 _v = 0;
43337 PyErr_Clear();
43338 } else {
43339 _v = 1;
43340 }
43341 }
43342 if (_v) {
43343 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43344 if (_v) {
43345 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43346 }
43347 }
43348 }
43349
43350 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43351 return NULL;
43352 }
43353
43354
43355 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43356 PyObject *resultobj;
43357 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43358 wxWindow *arg2 = (wxWindow *) 0 ;
43359 wxGBPosition *arg3 = 0 ;
43360 bool result;
43361 wxGBPosition temp3 ;
43362 PyObject * obj0 = 0 ;
43363 PyObject * obj1 = 0 ;
43364 PyObject * obj2 = 0 ;
43365
43366 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43368 if (SWIG_arg_fail(1)) SWIG_fail;
43369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43370 if (SWIG_arg_fail(2)) SWIG_fail;
43371 {
43372 arg3 = &temp3;
43373 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43374 }
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43378
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 {
43383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43384 }
43385 return resultobj;
43386 fail:
43387 return NULL;
43388 }
43389
43390
43391 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43392 PyObject *resultobj;
43393 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43394 wxSizer *arg2 = (wxSizer *) 0 ;
43395 wxGBPosition *arg3 = 0 ;
43396 bool result;
43397 wxGBPosition temp3 ;
43398 PyObject * obj0 = 0 ;
43399 PyObject * obj1 = 0 ;
43400 PyObject * obj2 = 0 ;
43401
43402 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43404 if (SWIG_arg_fail(1)) SWIG_fail;
43405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43406 if (SWIG_arg_fail(2)) SWIG_fail;
43407 {
43408 arg3 = &temp3;
43409 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43410 }
43411 {
43412 PyThreadState* __tstate = wxPyBeginAllowThreads();
43413 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43414
43415 wxPyEndAllowThreads(__tstate);
43416 if (PyErr_Occurred()) SWIG_fail;
43417 }
43418 {
43419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43420 }
43421 return resultobj;
43422 fail:
43423 return NULL;
43424 }
43425
43426
43427 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43428 PyObject *resultobj;
43429 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43430 size_t arg2 ;
43431 wxGBPosition *arg3 = 0 ;
43432 bool result;
43433 wxGBPosition temp3 ;
43434 PyObject * obj0 = 0 ;
43435 PyObject * obj1 = 0 ;
43436 PyObject * obj2 = 0 ;
43437
43438 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43440 if (SWIG_arg_fail(1)) SWIG_fail;
43441 {
43442 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43443 if (SWIG_arg_fail(2)) SWIG_fail;
43444 }
43445 {
43446 arg3 = &temp3;
43447 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43448 }
43449 {
43450 PyThreadState* __tstate = wxPyBeginAllowThreads();
43451 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43452
43453 wxPyEndAllowThreads(__tstate);
43454 if (PyErr_Occurred()) SWIG_fail;
43455 }
43456 {
43457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43458 }
43459 return resultobj;
43460 fail:
43461 return NULL;
43462 }
43463
43464
43465 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43466 int argc;
43467 PyObject *argv[4];
43468 int ii;
43469
43470 argc = PyObject_Length(args);
43471 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43472 argv[ii] = PyTuple_GetItem(args,ii);
43473 }
43474 if (argc == 3) {
43475 int _v;
43476 {
43477 void *ptr;
43478 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43479 _v = 0;
43480 PyErr_Clear();
43481 } else {
43482 _v = 1;
43483 }
43484 }
43485 if (_v) {
43486 {
43487 void *ptr;
43488 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43489 _v = 0;
43490 PyErr_Clear();
43491 } else {
43492 _v = 1;
43493 }
43494 }
43495 if (_v) {
43496 {
43497 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43498 }
43499 if (_v) {
43500 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43501 }
43502 }
43503 }
43504 }
43505 if (argc == 3) {
43506 int _v;
43507 {
43508 void *ptr;
43509 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43510 _v = 0;
43511 PyErr_Clear();
43512 } else {
43513 _v = 1;
43514 }
43515 }
43516 if (_v) {
43517 {
43518 void *ptr;
43519 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43520 _v = 0;
43521 PyErr_Clear();
43522 } else {
43523 _v = 1;
43524 }
43525 }
43526 if (_v) {
43527 {
43528 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43529 }
43530 if (_v) {
43531 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43532 }
43533 }
43534 }
43535 }
43536 if (argc == 3) {
43537 int _v;
43538 {
43539 void *ptr;
43540 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43541 _v = 0;
43542 PyErr_Clear();
43543 } else {
43544 _v = 1;
43545 }
43546 }
43547 if (_v) {
43548 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43549 if (_v) {
43550 {
43551 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43552 }
43553 if (_v) {
43554 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43555 }
43556 }
43557 }
43558 }
43559
43560 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43561 return NULL;
43562 }
43563
43564
43565 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43566 PyObject *resultobj;
43567 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43568 wxWindow *arg2 = (wxWindow *) 0 ;
43569 wxGBSpan result;
43570 PyObject * obj0 = 0 ;
43571 PyObject * obj1 = 0 ;
43572
43573 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43575 if (SWIG_arg_fail(1)) SWIG_fail;
43576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43577 if (SWIG_arg_fail(2)) SWIG_fail;
43578 {
43579 PyThreadState* __tstate = wxPyBeginAllowThreads();
43580 result = (arg1)->GetItemSpan(arg2);
43581
43582 wxPyEndAllowThreads(__tstate);
43583 if (PyErr_Occurred()) SWIG_fail;
43584 }
43585 {
43586 wxGBSpan * resultptr;
43587 resultptr = new wxGBSpan((wxGBSpan &)(result));
43588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43589 }
43590 return resultobj;
43591 fail:
43592 return NULL;
43593 }
43594
43595
43596 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43597 PyObject *resultobj;
43598 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43599 wxSizer *arg2 = (wxSizer *) 0 ;
43600 wxGBSpan result;
43601 PyObject * obj0 = 0 ;
43602 PyObject * obj1 = 0 ;
43603
43604 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43606 if (SWIG_arg_fail(1)) SWIG_fail;
43607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43608 if (SWIG_arg_fail(2)) SWIG_fail;
43609 {
43610 PyThreadState* __tstate = wxPyBeginAllowThreads();
43611 result = (arg1)->GetItemSpan(arg2);
43612
43613 wxPyEndAllowThreads(__tstate);
43614 if (PyErr_Occurred()) SWIG_fail;
43615 }
43616 {
43617 wxGBSpan * resultptr;
43618 resultptr = new wxGBSpan((wxGBSpan &)(result));
43619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43620 }
43621 return resultobj;
43622 fail:
43623 return NULL;
43624 }
43625
43626
43627 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43628 PyObject *resultobj;
43629 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43630 size_t arg2 ;
43631 wxGBSpan result;
43632 PyObject * obj0 = 0 ;
43633 PyObject * obj1 = 0 ;
43634
43635 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43637 if (SWIG_arg_fail(1)) SWIG_fail;
43638 {
43639 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43640 if (SWIG_arg_fail(2)) SWIG_fail;
43641 }
43642 {
43643 PyThreadState* __tstate = wxPyBeginAllowThreads();
43644 result = (arg1)->GetItemSpan(arg2);
43645
43646 wxPyEndAllowThreads(__tstate);
43647 if (PyErr_Occurred()) SWIG_fail;
43648 }
43649 {
43650 wxGBSpan * resultptr;
43651 resultptr = new wxGBSpan((wxGBSpan &)(result));
43652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43653 }
43654 return resultobj;
43655 fail:
43656 return NULL;
43657 }
43658
43659
43660 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43661 int argc;
43662 PyObject *argv[3];
43663 int ii;
43664
43665 argc = PyObject_Length(args);
43666 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43667 argv[ii] = PyTuple_GetItem(args,ii);
43668 }
43669 if (argc == 2) {
43670 int _v;
43671 {
43672 void *ptr;
43673 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43674 _v = 0;
43675 PyErr_Clear();
43676 } else {
43677 _v = 1;
43678 }
43679 }
43680 if (_v) {
43681 {
43682 void *ptr;
43683 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43684 _v = 0;
43685 PyErr_Clear();
43686 } else {
43687 _v = 1;
43688 }
43689 }
43690 if (_v) {
43691 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43692 }
43693 }
43694 }
43695 if (argc == 2) {
43696 int _v;
43697 {
43698 void *ptr;
43699 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43700 _v = 0;
43701 PyErr_Clear();
43702 } else {
43703 _v = 1;
43704 }
43705 }
43706 if (_v) {
43707 {
43708 void *ptr;
43709 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43710 _v = 0;
43711 PyErr_Clear();
43712 } else {
43713 _v = 1;
43714 }
43715 }
43716 if (_v) {
43717 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43718 }
43719 }
43720 }
43721 if (argc == 2) {
43722 int _v;
43723 {
43724 void *ptr;
43725 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43726 _v = 0;
43727 PyErr_Clear();
43728 } else {
43729 _v = 1;
43730 }
43731 }
43732 if (_v) {
43733 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43734 if (_v) {
43735 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43736 }
43737 }
43738 }
43739
43740 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43741 return NULL;
43742 }
43743
43744
43745 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43746 PyObject *resultobj;
43747 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43748 wxWindow *arg2 = (wxWindow *) 0 ;
43749 wxGBSpan *arg3 = 0 ;
43750 bool result;
43751 wxGBSpan temp3 ;
43752 PyObject * obj0 = 0 ;
43753 PyObject * obj1 = 0 ;
43754 PyObject * obj2 = 0 ;
43755
43756 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43758 if (SWIG_arg_fail(1)) SWIG_fail;
43759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43760 if (SWIG_arg_fail(2)) SWIG_fail;
43761 {
43762 arg3 = &temp3;
43763 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43764 }
43765 {
43766 PyThreadState* __tstate = wxPyBeginAllowThreads();
43767 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43768
43769 wxPyEndAllowThreads(__tstate);
43770 if (PyErr_Occurred()) SWIG_fail;
43771 }
43772 {
43773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43774 }
43775 return resultobj;
43776 fail:
43777 return NULL;
43778 }
43779
43780
43781 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43782 PyObject *resultobj;
43783 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43784 wxSizer *arg2 = (wxSizer *) 0 ;
43785 wxGBSpan *arg3 = 0 ;
43786 bool result;
43787 wxGBSpan temp3 ;
43788 PyObject * obj0 = 0 ;
43789 PyObject * obj1 = 0 ;
43790 PyObject * obj2 = 0 ;
43791
43792 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43794 if (SWIG_arg_fail(1)) SWIG_fail;
43795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43796 if (SWIG_arg_fail(2)) SWIG_fail;
43797 {
43798 arg3 = &temp3;
43799 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43800 }
43801 {
43802 PyThreadState* __tstate = wxPyBeginAllowThreads();
43803 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43804
43805 wxPyEndAllowThreads(__tstate);
43806 if (PyErr_Occurred()) SWIG_fail;
43807 }
43808 {
43809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43810 }
43811 return resultobj;
43812 fail:
43813 return NULL;
43814 }
43815
43816
43817 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43818 PyObject *resultobj;
43819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43820 size_t arg2 ;
43821 wxGBSpan *arg3 = 0 ;
43822 bool result;
43823 wxGBSpan temp3 ;
43824 PyObject * obj0 = 0 ;
43825 PyObject * obj1 = 0 ;
43826 PyObject * obj2 = 0 ;
43827
43828 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43830 if (SWIG_arg_fail(1)) SWIG_fail;
43831 {
43832 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43833 if (SWIG_arg_fail(2)) SWIG_fail;
43834 }
43835 {
43836 arg3 = &temp3;
43837 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43838 }
43839 {
43840 PyThreadState* __tstate = wxPyBeginAllowThreads();
43841 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43842
43843 wxPyEndAllowThreads(__tstate);
43844 if (PyErr_Occurred()) SWIG_fail;
43845 }
43846 {
43847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43848 }
43849 return resultobj;
43850 fail:
43851 return NULL;
43852 }
43853
43854
43855 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43856 int argc;
43857 PyObject *argv[4];
43858 int ii;
43859
43860 argc = PyObject_Length(args);
43861 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43862 argv[ii] = PyTuple_GetItem(args,ii);
43863 }
43864 if (argc == 3) {
43865 int _v;
43866 {
43867 void *ptr;
43868 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43869 _v = 0;
43870 PyErr_Clear();
43871 } else {
43872 _v = 1;
43873 }
43874 }
43875 if (_v) {
43876 {
43877 void *ptr;
43878 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43879 _v = 0;
43880 PyErr_Clear();
43881 } else {
43882 _v = 1;
43883 }
43884 }
43885 if (_v) {
43886 {
43887 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43888 }
43889 if (_v) {
43890 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43891 }
43892 }
43893 }
43894 }
43895 if (argc == 3) {
43896 int _v;
43897 {
43898 void *ptr;
43899 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43900 _v = 0;
43901 PyErr_Clear();
43902 } else {
43903 _v = 1;
43904 }
43905 }
43906 if (_v) {
43907 {
43908 void *ptr;
43909 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43910 _v = 0;
43911 PyErr_Clear();
43912 } else {
43913 _v = 1;
43914 }
43915 }
43916 if (_v) {
43917 {
43918 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43919 }
43920 if (_v) {
43921 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43922 }
43923 }
43924 }
43925 }
43926 if (argc == 3) {
43927 int _v;
43928 {
43929 void *ptr;
43930 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43931 _v = 0;
43932 PyErr_Clear();
43933 } else {
43934 _v = 1;
43935 }
43936 }
43937 if (_v) {
43938 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43939 if (_v) {
43940 {
43941 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43942 }
43943 if (_v) {
43944 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43945 }
43946 }
43947 }
43948 }
43949
43950 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43951 return NULL;
43952 }
43953
43954
43955 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43956 PyObject *resultobj;
43957 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43958 wxWindow *arg2 = (wxWindow *) 0 ;
43959 wxGBSizerItem *result;
43960 PyObject * obj0 = 0 ;
43961 PyObject * obj1 = 0 ;
43962
43963 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43965 if (SWIG_arg_fail(1)) SWIG_fail;
43966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43967 if (SWIG_arg_fail(2)) SWIG_fail;
43968 {
43969 PyThreadState* __tstate = wxPyBeginAllowThreads();
43970 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43971
43972 wxPyEndAllowThreads(__tstate);
43973 if (PyErr_Occurred()) SWIG_fail;
43974 }
43975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43983 PyObject *resultobj;
43984 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43985 wxSizer *arg2 = (wxSizer *) 0 ;
43986 wxGBSizerItem *result;
43987 PyObject * obj0 = 0 ;
43988 PyObject * obj1 = 0 ;
43989
43990 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43992 if (SWIG_arg_fail(1)) SWIG_fail;
43993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43994 if (SWIG_arg_fail(2)) SWIG_fail;
43995 {
43996 PyThreadState* __tstate = wxPyBeginAllowThreads();
43997 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43998
43999 wxPyEndAllowThreads(__tstate);
44000 if (PyErr_Occurred()) SWIG_fail;
44001 }
44002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44003 return resultobj;
44004 fail:
44005 return NULL;
44006 }
44007
44008
44009 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44010 int argc;
44011 PyObject *argv[3];
44012 int ii;
44013
44014 argc = PyObject_Length(args);
44015 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44016 argv[ii] = PyTuple_GetItem(args,ii);
44017 }
44018 if (argc == 2) {
44019 int _v;
44020 {
44021 void *ptr;
44022 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44023 _v = 0;
44024 PyErr_Clear();
44025 } else {
44026 _v = 1;
44027 }
44028 }
44029 if (_v) {
44030 {
44031 void *ptr;
44032 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44033 _v = 0;
44034 PyErr_Clear();
44035 } else {
44036 _v = 1;
44037 }
44038 }
44039 if (_v) {
44040 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44041 }
44042 }
44043 }
44044 if (argc == 2) {
44045 int _v;
44046 {
44047 void *ptr;
44048 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44049 _v = 0;
44050 PyErr_Clear();
44051 } else {
44052 _v = 1;
44053 }
44054 }
44055 if (_v) {
44056 {
44057 void *ptr;
44058 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44059 _v = 0;
44060 PyErr_Clear();
44061 } else {
44062 _v = 1;
44063 }
44064 }
44065 if (_v) {
44066 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44067 }
44068 }
44069 }
44070
44071 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44072 return NULL;
44073 }
44074
44075
44076 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44077 PyObject *resultobj;
44078 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44079 wxGBPosition *arg2 = 0 ;
44080 wxGBSizerItem *result;
44081 wxGBPosition temp2 ;
44082 PyObject * obj0 = 0 ;
44083 PyObject * obj1 = 0 ;
44084 char *kwnames[] = {
44085 (char *) "self",(char *) "pos", NULL
44086 };
44087
44088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44090 if (SWIG_arg_fail(1)) SWIG_fail;
44091 {
44092 arg2 = &temp2;
44093 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44094 }
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44098
44099 wxPyEndAllowThreads(__tstate);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 }
44102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44103 return resultobj;
44104 fail:
44105 return NULL;
44106 }
44107
44108
44109 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44110 PyObject *resultobj;
44111 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44112 wxPoint *arg2 = 0 ;
44113 wxGBSizerItem *result;
44114 wxPoint temp2 ;
44115 PyObject * obj0 = 0 ;
44116 PyObject * obj1 = 0 ;
44117 char *kwnames[] = {
44118 (char *) "self",(char *) "pt", NULL
44119 };
44120
44121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44123 if (SWIG_arg_fail(1)) SWIG_fail;
44124 {
44125 arg2 = &temp2;
44126 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44127 }
44128 {
44129 PyThreadState* __tstate = wxPyBeginAllowThreads();
44130 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44131
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44136 return resultobj;
44137 fail:
44138 return NULL;
44139 }
44140
44141
44142 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44143 PyObject *resultobj;
44144 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44145 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44146 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44147 bool result;
44148 PyObject * obj0 = 0 ;
44149 PyObject * obj1 = 0 ;
44150 PyObject * obj2 = 0 ;
44151 char *kwnames[] = {
44152 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44153 };
44154
44155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44157 if (SWIG_arg_fail(1)) SWIG_fail;
44158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44159 if (SWIG_arg_fail(2)) SWIG_fail;
44160 if (obj2) {
44161 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44162 if (SWIG_arg_fail(3)) SWIG_fail;
44163 }
44164 {
44165 PyThreadState* __tstate = wxPyBeginAllowThreads();
44166 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44167
44168 wxPyEndAllowThreads(__tstate);
44169 if (PyErr_Occurred()) SWIG_fail;
44170 }
44171 {
44172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44173 }
44174 return resultobj;
44175 fail:
44176 return NULL;
44177 }
44178
44179
44180 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44181 PyObject *resultobj;
44182 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44183 wxGBPosition *arg2 = 0 ;
44184 wxGBSpan *arg3 = 0 ;
44185 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44186 bool result;
44187 wxGBPosition temp2 ;
44188 wxGBSpan temp3 ;
44189 PyObject * obj0 = 0 ;
44190 PyObject * obj1 = 0 ;
44191 PyObject * obj2 = 0 ;
44192 PyObject * obj3 = 0 ;
44193 char *kwnames[] = {
44194 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44195 };
44196
44197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44199 if (SWIG_arg_fail(1)) SWIG_fail;
44200 {
44201 arg2 = &temp2;
44202 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44203 }
44204 {
44205 arg3 = &temp3;
44206 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44207 }
44208 if (obj3) {
44209 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44210 if (SWIG_arg_fail(4)) SWIG_fail;
44211 }
44212 {
44213 PyThreadState* __tstate = wxPyBeginAllowThreads();
44214 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44215
44216 wxPyEndAllowThreads(__tstate);
44217 if (PyErr_Occurred()) SWIG_fail;
44218 }
44219 {
44220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44221 }
44222 return resultobj;
44223 fail:
44224 return NULL;
44225 }
44226
44227
44228 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44229 PyObject *obj;
44230 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44231 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44232 Py_INCREF(obj);
44233 return Py_BuildValue((char *)"");
44234 }
44235 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44236 PyObject *resultobj;
44237 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44238 wxRelationship arg2 ;
44239 wxWindow *arg3 = (wxWindow *) 0 ;
44240 wxEdge arg4 ;
44241 int arg5 = (int) 0 ;
44242 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44243 PyObject * obj0 = 0 ;
44244 PyObject * obj1 = 0 ;
44245 PyObject * obj2 = 0 ;
44246 PyObject * obj3 = 0 ;
44247 PyObject * obj4 = 0 ;
44248 PyObject * obj5 = 0 ;
44249 char *kwnames[] = {
44250 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44251 };
44252
44253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44255 if (SWIG_arg_fail(1)) SWIG_fail;
44256 {
44257 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44258 if (SWIG_arg_fail(2)) SWIG_fail;
44259 }
44260 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44261 if (SWIG_arg_fail(3)) SWIG_fail;
44262 {
44263 arg4 = (wxEdge)(SWIG_As_int(obj3));
44264 if (SWIG_arg_fail(4)) SWIG_fail;
44265 }
44266 if (obj4) {
44267 {
44268 arg5 = (int)(SWIG_As_int(obj4));
44269 if (SWIG_arg_fail(5)) SWIG_fail;
44270 }
44271 }
44272 if (obj5) {
44273 {
44274 arg6 = (int)(SWIG_As_int(obj5));
44275 if (SWIG_arg_fail(6)) SWIG_fail;
44276 }
44277 }
44278 {
44279 PyThreadState* __tstate = wxPyBeginAllowThreads();
44280 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44281
44282 wxPyEndAllowThreads(__tstate);
44283 if (PyErr_Occurred()) SWIG_fail;
44284 }
44285 Py_INCREF(Py_None); resultobj = Py_None;
44286 return resultobj;
44287 fail:
44288 return NULL;
44289 }
44290
44291
44292 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44293 PyObject *resultobj;
44294 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44295 wxWindow *arg2 = (wxWindow *) 0 ;
44296 int arg3 = (int) 0 ;
44297 PyObject * obj0 = 0 ;
44298 PyObject * obj1 = 0 ;
44299 PyObject * obj2 = 0 ;
44300 char *kwnames[] = {
44301 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44302 };
44303
44304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44306 if (SWIG_arg_fail(1)) SWIG_fail;
44307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44308 if (SWIG_arg_fail(2)) SWIG_fail;
44309 if (obj2) {
44310 {
44311 arg3 = (int)(SWIG_As_int(obj2));
44312 if (SWIG_arg_fail(3)) SWIG_fail;
44313 }
44314 }
44315 {
44316 PyThreadState* __tstate = wxPyBeginAllowThreads();
44317 (arg1)->LeftOf(arg2,arg3);
44318
44319 wxPyEndAllowThreads(__tstate);
44320 if (PyErr_Occurred()) SWIG_fail;
44321 }
44322 Py_INCREF(Py_None); resultobj = Py_None;
44323 return resultobj;
44324 fail:
44325 return NULL;
44326 }
44327
44328
44329 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44330 PyObject *resultobj;
44331 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44332 wxWindow *arg2 = (wxWindow *) 0 ;
44333 int arg3 = (int) 0 ;
44334 PyObject * obj0 = 0 ;
44335 PyObject * obj1 = 0 ;
44336 PyObject * obj2 = 0 ;
44337 char *kwnames[] = {
44338 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44339 };
44340
44341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44343 if (SWIG_arg_fail(1)) SWIG_fail;
44344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44345 if (SWIG_arg_fail(2)) SWIG_fail;
44346 if (obj2) {
44347 {
44348 arg3 = (int)(SWIG_As_int(obj2));
44349 if (SWIG_arg_fail(3)) SWIG_fail;
44350 }
44351 }
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 (arg1)->RightOf(arg2,arg3);
44355
44356 wxPyEndAllowThreads(__tstate);
44357 if (PyErr_Occurred()) SWIG_fail;
44358 }
44359 Py_INCREF(Py_None); resultobj = Py_None;
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44367 PyObject *resultobj;
44368 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44369 wxWindow *arg2 = (wxWindow *) 0 ;
44370 int arg3 = (int) 0 ;
44371 PyObject * obj0 = 0 ;
44372 PyObject * obj1 = 0 ;
44373 PyObject * obj2 = 0 ;
44374 char *kwnames[] = {
44375 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44376 };
44377
44378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44380 if (SWIG_arg_fail(1)) SWIG_fail;
44381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44382 if (SWIG_arg_fail(2)) SWIG_fail;
44383 if (obj2) {
44384 {
44385 arg3 = (int)(SWIG_As_int(obj2));
44386 if (SWIG_arg_fail(3)) SWIG_fail;
44387 }
44388 }
44389 {
44390 PyThreadState* __tstate = wxPyBeginAllowThreads();
44391 (arg1)->Above(arg2,arg3);
44392
44393 wxPyEndAllowThreads(__tstate);
44394 if (PyErr_Occurred()) SWIG_fail;
44395 }
44396 Py_INCREF(Py_None); resultobj = Py_None;
44397 return resultobj;
44398 fail:
44399 return NULL;
44400 }
44401
44402
44403 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44404 PyObject *resultobj;
44405 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44406 wxWindow *arg2 = (wxWindow *) 0 ;
44407 int arg3 = (int) 0 ;
44408 PyObject * obj0 = 0 ;
44409 PyObject * obj1 = 0 ;
44410 PyObject * obj2 = 0 ;
44411 char *kwnames[] = {
44412 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44413 };
44414
44415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44417 if (SWIG_arg_fail(1)) SWIG_fail;
44418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44419 if (SWIG_arg_fail(2)) SWIG_fail;
44420 if (obj2) {
44421 {
44422 arg3 = (int)(SWIG_As_int(obj2));
44423 if (SWIG_arg_fail(3)) SWIG_fail;
44424 }
44425 }
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 (arg1)->Below(arg2,arg3);
44429
44430 wxPyEndAllowThreads(__tstate);
44431 if (PyErr_Occurred()) SWIG_fail;
44432 }
44433 Py_INCREF(Py_None); resultobj = Py_None;
44434 return resultobj;
44435 fail:
44436 return NULL;
44437 }
44438
44439
44440 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44441 PyObject *resultobj;
44442 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44443 wxWindow *arg2 = (wxWindow *) 0 ;
44444 wxEdge arg3 ;
44445 int arg4 = (int) 0 ;
44446 PyObject * obj0 = 0 ;
44447 PyObject * obj1 = 0 ;
44448 PyObject * obj2 = 0 ;
44449 PyObject * obj3 = 0 ;
44450 char *kwnames[] = {
44451 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44452 };
44453
44454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44456 if (SWIG_arg_fail(1)) SWIG_fail;
44457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44458 if (SWIG_arg_fail(2)) SWIG_fail;
44459 {
44460 arg3 = (wxEdge)(SWIG_As_int(obj2));
44461 if (SWIG_arg_fail(3)) SWIG_fail;
44462 }
44463 if (obj3) {
44464 {
44465 arg4 = (int)(SWIG_As_int(obj3));
44466 if (SWIG_arg_fail(4)) SWIG_fail;
44467 }
44468 }
44469 {
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44472
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 Py_INCREF(Py_None); resultobj = Py_None;
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44484 PyObject *resultobj;
44485 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44486 wxWindow *arg2 = (wxWindow *) 0 ;
44487 wxEdge arg3 ;
44488 int arg4 ;
44489 PyObject * obj0 = 0 ;
44490 PyObject * obj1 = 0 ;
44491 PyObject * obj2 = 0 ;
44492 PyObject * obj3 = 0 ;
44493 char *kwnames[] = {
44494 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44495 };
44496
44497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44499 if (SWIG_arg_fail(1)) SWIG_fail;
44500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44501 if (SWIG_arg_fail(2)) SWIG_fail;
44502 {
44503 arg3 = (wxEdge)(SWIG_As_int(obj2));
44504 if (SWIG_arg_fail(3)) SWIG_fail;
44505 }
44506 {
44507 arg4 = (int)(SWIG_As_int(obj3));
44508 if (SWIG_arg_fail(4)) SWIG_fail;
44509 }
44510 {
44511 PyThreadState* __tstate = wxPyBeginAllowThreads();
44512 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44513
44514 wxPyEndAllowThreads(__tstate);
44515 if (PyErr_Occurred()) SWIG_fail;
44516 }
44517 Py_INCREF(Py_None); resultobj = Py_None;
44518 return resultobj;
44519 fail:
44520 return NULL;
44521 }
44522
44523
44524 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44525 PyObject *resultobj;
44526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44527 int arg2 ;
44528 PyObject * obj0 = 0 ;
44529 PyObject * obj1 = 0 ;
44530 char *kwnames[] = {
44531 (char *) "self",(char *) "val", NULL
44532 };
44533
44534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44536 if (SWIG_arg_fail(1)) SWIG_fail;
44537 {
44538 arg2 = (int)(SWIG_As_int(obj1));
44539 if (SWIG_arg_fail(2)) SWIG_fail;
44540 }
44541 {
44542 PyThreadState* __tstate = wxPyBeginAllowThreads();
44543 (arg1)->Absolute(arg2);
44544
44545 wxPyEndAllowThreads(__tstate);
44546 if (PyErr_Occurred()) SWIG_fail;
44547 }
44548 Py_INCREF(Py_None); resultobj = Py_None;
44549 return resultobj;
44550 fail:
44551 return NULL;
44552 }
44553
44554
44555 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44556 PyObject *resultobj;
44557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44558 PyObject * obj0 = 0 ;
44559 char *kwnames[] = {
44560 (char *) "self", NULL
44561 };
44562
44563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44565 if (SWIG_arg_fail(1)) SWIG_fail;
44566 {
44567 PyThreadState* __tstate = wxPyBeginAllowThreads();
44568 (arg1)->Unconstrained();
44569
44570 wxPyEndAllowThreads(__tstate);
44571 if (PyErr_Occurred()) SWIG_fail;
44572 }
44573 Py_INCREF(Py_None); resultobj = Py_None;
44574 return resultobj;
44575 fail:
44576 return NULL;
44577 }
44578
44579
44580 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44581 PyObject *resultobj;
44582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44583 PyObject * obj0 = 0 ;
44584 char *kwnames[] = {
44585 (char *) "self", NULL
44586 };
44587
44588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44590 if (SWIG_arg_fail(1)) SWIG_fail;
44591 {
44592 PyThreadState* __tstate = wxPyBeginAllowThreads();
44593 (arg1)->AsIs();
44594
44595 wxPyEndAllowThreads(__tstate);
44596 if (PyErr_Occurred()) SWIG_fail;
44597 }
44598 Py_INCREF(Py_None); resultobj = Py_None;
44599 return resultobj;
44600 fail:
44601 return NULL;
44602 }
44603
44604
44605 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44606 PyObject *resultobj;
44607 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44608 wxWindow *result;
44609 PyObject * obj0 = 0 ;
44610 char *kwnames[] = {
44611 (char *) "self", NULL
44612 };
44613
44614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44616 if (SWIG_arg_fail(1)) SWIG_fail;
44617 {
44618 PyThreadState* __tstate = wxPyBeginAllowThreads();
44619 result = (wxWindow *)(arg1)->GetOtherWindow();
44620
44621 wxPyEndAllowThreads(__tstate);
44622 if (PyErr_Occurred()) SWIG_fail;
44623 }
44624 {
44625 resultobj = wxPyMake_wxObject(result, 0);
44626 }
44627 return resultobj;
44628 fail:
44629 return NULL;
44630 }
44631
44632
44633 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44634 PyObject *resultobj;
44635 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44636 wxEdge result;
44637 PyObject * obj0 = 0 ;
44638 char *kwnames[] = {
44639 (char *) "self", NULL
44640 };
44641
44642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44644 if (SWIG_arg_fail(1)) SWIG_fail;
44645 {
44646 PyThreadState* __tstate = wxPyBeginAllowThreads();
44647 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44648
44649 wxPyEndAllowThreads(__tstate);
44650 if (PyErr_Occurred()) SWIG_fail;
44651 }
44652 resultobj = SWIG_From_int((result));
44653 return resultobj;
44654 fail:
44655 return NULL;
44656 }
44657
44658
44659 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44660 PyObject *resultobj;
44661 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44662 wxEdge arg2 ;
44663 PyObject * obj0 = 0 ;
44664 PyObject * obj1 = 0 ;
44665 char *kwnames[] = {
44666 (char *) "self",(char *) "which", NULL
44667 };
44668
44669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44671 if (SWIG_arg_fail(1)) SWIG_fail;
44672 {
44673 arg2 = (wxEdge)(SWIG_As_int(obj1));
44674 if (SWIG_arg_fail(2)) SWIG_fail;
44675 }
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 (arg1)->SetEdge((wxEdge )arg2);
44679
44680 wxPyEndAllowThreads(__tstate);
44681 if (PyErr_Occurred()) SWIG_fail;
44682 }
44683 Py_INCREF(Py_None); resultobj = Py_None;
44684 return resultobj;
44685 fail:
44686 return NULL;
44687 }
44688
44689
44690 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44691 PyObject *resultobj;
44692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44693 int arg2 ;
44694 PyObject * obj0 = 0 ;
44695 PyObject * obj1 = 0 ;
44696 char *kwnames[] = {
44697 (char *) "self",(char *) "v", NULL
44698 };
44699
44700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44702 if (SWIG_arg_fail(1)) SWIG_fail;
44703 {
44704 arg2 = (int)(SWIG_As_int(obj1));
44705 if (SWIG_arg_fail(2)) SWIG_fail;
44706 }
44707 {
44708 PyThreadState* __tstate = wxPyBeginAllowThreads();
44709 (arg1)->SetValue(arg2);
44710
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 Py_INCREF(Py_None); resultobj = Py_None;
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44722 PyObject *resultobj;
44723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44724 int result;
44725 PyObject * obj0 = 0 ;
44726 char *kwnames[] = {
44727 (char *) "self", NULL
44728 };
44729
44730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44732 if (SWIG_arg_fail(1)) SWIG_fail;
44733 {
44734 PyThreadState* __tstate = wxPyBeginAllowThreads();
44735 result = (int)(arg1)->GetMargin();
44736
44737 wxPyEndAllowThreads(__tstate);
44738 if (PyErr_Occurred()) SWIG_fail;
44739 }
44740 {
44741 resultobj = SWIG_From_int((int)(result));
44742 }
44743 return resultobj;
44744 fail:
44745 return NULL;
44746 }
44747
44748
44749 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44750 PyObject *resultobj;
44751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44752 int arg2 ;
44753 PyObject * obj0 = 0 ;
44754 PyObject * obj1 = 0 ;
44755 char *kwnames[] = {
44756 (char *) "self",(char *) "m", NULL
44757 };
44758
44759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44761 if (SWIG_arg_fail(1)) SWIG_fail;
44762 {
44763 arg2 = (int)(SWIG_As_int(obj1));
44764 if (SWIG_arg_fail(2)) SWIG_fail;
44765 }
44766 {
44767 PyThreadState* __tstate = wxPyBeginAllowThreads();
44768 (arg1)->SetMargin(arg2);
44769
44770 wxPyEndAllowThreads(__tstate);
44771 if (PyErr_Occurred()) SWIG_fail;
44772 }
44773 Py_INCREF(Py_None); resultobj = Py_None;
44774 return resultobj;
44775 fail:
44776 return NULL;
44777 }
44778
44779
44780 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44781 PyObject *resultobj;
44782 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44783 int result;
44784 PyObject * obj0 = 0 ;
44785 char *kwnames[] = {
44786 (char *) "self", NULL
44787 };
44788
44789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44791 if (SWIG_arg_fail(1)) SWIG_fail;
44792 {
44793 PyThreadState* __tstate = wxPyBeginAllowThreads();
44794 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44795
44796 wxPyEndAllowThreads(__tstate);
44797 if (PyErr_Occurred()) SWIG_fail;
44798 }
44799 {
44800 resultobj = SWIG_From_int((int)(result));
44801 }
44802 return resultobj;
44803 fail:
44804 return NULL;
44805 }
44806
44807
44808 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44809 PyObject *resultobj;
44810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44811 int result;
44812 PyObject * obj0 = 0 ;
44813 char *kwnames[] = {
44814 (char *) "self", NULL
44815 };
44816
44817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44819 if (SWIG_arg_fail(1)) SWIG_fail;
44820 {
44821 PyThreadState* __tstate = wxPyBeginAllowThreads();
44822 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44823
44824 wxPyEndAllowThreads(__tstate);
44825 if (PyErr_Occurred()) SWIG_fail;
44826 }
44827 {
44828 resultobj = SWIG_From_int((int)(result));
44829 }
44830 return resultobj;
44831 fail:
44832 return NULL;
44833 }
44834
44835
44836 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44837 PyObject *resultobj;
44838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44839 int result;
44840 PyObject * obj0 = 0 ;
44841 char *kwnames[] = {
44842 (char *) "self", NULL
44843 };
44844
44845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44847 if (SWIG_arg_fail(1)) SWIG_fail;
44848 {
44849 PyThreadState* __tstate = wxPyBeginAllowThreads();
44850 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44851
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 {
44856 resultobj = SWIG_From_int((int)(result));
44857 }
44858 return resultobj;
44859 fail:
44860 return NULL;
44861 }
44862
44863
44864 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44865 PyObject *resultobj;
44866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44867 bool result;
44868 PyObject * obj0 = 0 ;
44869 char *kwnames[] = {
44870 (char *) "self", NULL
44871 };
44872
44873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44875 if (SWIG_arg_fail(1)) SWIG_fail;
44876 {
44877 PyThreadState* __tstate = wxPyBeginAllowThreads();
44878 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44879
44880 wxPyEndAllowThreads(__tstate);
44881 if (PyErr_Occurred()) SWIG_fail;
44882 }
44883 {
44884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44885 }
44886 return resultobj;
44887 fail:
44888 return NULL;
44889 }
44890
44891
44892 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44893 PyObject *resultobj;
44894 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44895 bool arg2 ;
44896 PyObject * obj0 = 0 ;
44897 PyObject * obj1 = 0 ;
44898 char *kwnames[] = {
44899 (char *) "self",(char *) "d", NULL
44900 };
44901
44902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44904 if (SWIG_arg_fail(1)) SWIG_fail;
44905 {
44906 arg2 = (bool)(SWIG_As_bool(obj1));
44907 if (SWIG_arg_fail(2)) SWIG_fail;
44908 }
44909 {
44910 PyThreadState* __tstate = wxPyBeginAllowThreads();
44911 (arg1)->SetDone(arg2);
44912
44913 wxPyEndAllowThreads(__tstate);
44914 if (PyErr_Occurred()) SWIG_fail;
44915 }
44916 Py_INCREF(Py_None); resultobj = Py_None;
44917 return resultobj;
44918 fail:
44919 return NULL;
44920 }
44921
44922
44923 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44924 PyObject *resultobj;
44925 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44926 wxRelationship result;
44927 PyObject * obj0 = 0 ;
44928 char *kwnames[] = {
44929 (char *) "self", NULL
44930 };
44931
44932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44934 if (SWIG_arg_fail(1)) SWIG_fail;
44935 {
44936 PyThreadState* __tstate = wxPyBeginAllowThreads();
44937 result = (wxRelationship)(arg1)->GetRelationship();
44938
44939 wxPyEndAllowThreads(__tstate);
44940 if (PyErr_Occurred()) SWIG_fail;
44941 }
44942 resultobj = SWIG_From_int((result));
44943 return resultobj;
44944 fail:
44945 return NULL;
44946 }
44947
44948
44949 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44950 PyObject *resultobj;
44951 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44952 wxRelationship arg2 ;
44953 PyObject * obj0 = 0 ;
44954 PyObject * obj1 = 0 ;
44955 char *kwnames[] = {
44956 (char *) "self",(char *) "r", NULL
44957 };
44958
44959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44961 if (SWIG_arg_fail(1)) SWIG_fail;
44962 {
44963 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44964 if (SWIG_arg_fail(2)) SWIG_fail;
44965 }
44966 {
44967 PyThreadState* __tstate = wxPyBeginAllowThreads();
44968 (arg1)->SetRelationship((wxRelationship )arg2);
44969
44970 wxPyEndAllowThreads(__tstate);
44971 if (PyErr_Occurred()) SWIG_fail;
44972 }
44973 Py_INCREF(Py_None); resultobj = Py_None;
44974 return resultobj;
44975 fail:
44976 return NULL;
44977 }
44978
44979
44980 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44981 PyObject *resultobj;
44982 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44983 wxWindow *arg2 = (wxWindow *) 0 ;
44984 bool result;
44985 PyObject * obj0 = 0 ;
44986 PyObject * obj1 = 0 ;
44987 char *kwnames[] = {
44988 (char *) "self",(char *) "otherW", NULL
44989 };
44990
44991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44993 if (SWIG_arg_fail(1)) SWIG_fail;
44994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44995 if (SWIG_arg_fail(2)) SWIG_fail;
44996 {
44997 PyThreadState* __tstate = wxPyBeginAllowThreads();
44998 result = (bool)(arg1)->ResetIfWin(arg2);
44999
45000 wxPyEndAllowThreads(__tstate);
45001 if (PyErr_Occurred()) SWIG_fail;
45002 }
45003 {
45004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45005 }
45006 return resultobj;
45007 fail:
45008 return NULL;
45009 }
45010
45011
45012 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45013 PyObject *resultobj;
45014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45015 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45016 wxWindow *arg3 = (wxWindow *) 0 ;
45017 bool result;
45018 PyObject * obj0 = 0 ;
45019 PyObject * obj1 = 0 ;
45020 PyObject * obj2 = 0 ;
45021 char *kwnames[] = {
45022 (char *) "self",(char *) "constraints",(char *) "win", NULL
45023 };
45024
45025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45027 if (SWIG_arg_fail(1)) SWIG_fail;
45028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45029 if (SWIG_arg_fail(2)) SWIG_fail;
45030 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45031 if (SWIG_arg_fail(3)) SWIG_fail;
45032 {
45033 PyThreadState* __tstate = wxPyBeginAllowThreads();
45034 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45035
45036 wxPyEndAllowThreads(__tstate);
45037 if (PyErr_Occurred()) SWIG_fail;
45038 }
45039 {
45040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45041 }
45042 return resultobj;
45043 fail:
45044 return NULL;
45045 }
45046
45047
45048 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45049 PyObject *resultobj;
45050 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45051 wxEdge arg2 ;
45052 wxWindow *arg3 = (wxWindow *) 0 ;
45053 wxWindow *arg4 = (wxWindow *) 0 ;
45054 int result;
45055 PyObject * obj0 = 0 ;
45056 PyObject * obj1 = 0 ;
45057 PyObject * obj2 = 0 ;
45058 PyObject * obj3 = 0 ;
45059 char *kwnames[] = {
45060 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45061 };
45062
45063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45065 if (SWIG_arg_fail(1)) SWIG_fail;
45066 {
45067 arg2 = (wxEdge)(SWIG_As_int(obj1));
45068 if (SWIG_arg_fail(2)) SWIG_fail;
45069 }
45070 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45071 if (SWIG_arg_fail(3)) SWIG_fail;
45072 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45073 if (SWIG_arg_fail(4)) SWIG_fail;
45074 {
45075 PyThreadState* __tstate = wxPyBeginAllowThreads();
45076 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45077
45078 wxPyEndAllowThreads(__tstate);
45079 if (PyErr_Occurred()) SWIG_fail;
45080 }
45081 {
45082 resultobj = SWIG_From_int((int)(result));
45083 }
45084 return resultobj;
45085 fail:
45086 return NULL;
45087 }
45088
45089
45090 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45091 PyObject *obj;
45092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45093 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45094 Py_INCREF(obj);
45095 return Py_BuildValue((char *)"");
45096 }
45097 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj;
45099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45100 wxIndividualLayoutConstraint *result;
45101 PyObject * obj0 = 0 ;
45102 char *kwnames[] = {
45103 (char *) "self", NULL
45104 };
45105
45106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45108 if (SWIG_arg_fail(1)) SWIG_fail;
45109 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45110
45111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45112 return resultobj;
45113 fail:
45114 return NULL;
45115 }
45116
45117
45118 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj;
45120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45121 wxIndividualLayoutConstraint *result;
45122 PyObject * obj0 = 0 ;
45123 char *kwnames[] = {
45124 (char *) "self", NULL
45125 };
45126
45127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45129 if (SWIG_arg_fail(1)) SWIG_fail;
45130 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45131
45132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj;
45141 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45142 wxIndividualLayoutConstraint *result;
45143 PyObject * obj0 = 0 ;
45144 char *kwnames[] = {
45145 (char *) "self", NULL
45146 };
45147
45148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45150 if (SWIG_arg_fail(1)) SWIG_fail;
45151 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45152
45153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45154 return resultobj;
45155 fail:
45156 return NULL;
45157 }
45158
45159
45160 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45161 PyObject *resultobj;
45162 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45163 wxIndividualLayoutConstraint *result;
45164 PyObject * obj0 = 0 ;
45165 char *kwnames[] = {
45166 (char *) "self", NULL
45167 };
45168
45169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45171 if (SWIG_arg_fail(1)) SWIG_fail;
45172 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45173
45174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj;
45183 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45184 wxIndividualLayoutConstraint *result;
45185 PyObject * obj0 = 0 ;
45186 char *kwnames[] = {
45187 (char *) "self", NULL
45188 };
45189
45190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45192 if (SWIG_arg_fail(1)) SWIG_fail;
45193 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45194
45195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45196 return resultobj;
45197 fail:
45198 return NULL;
45199 }
45200
45201
45202 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45203 PyObject *resultobj;
45204 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45205 wxIndividualLayoutConstraint *result;
45206 PyObject * obj0 = 0 ;
45207 char *kwnames[] = {
45208 (char *) "self", NULL
45209 };
45210
45211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45213 if (SWIG_arg_fail(1)) SWIG_fail;
45214 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45215
45216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45224 PyObject *resultobj;
45225 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45226 wxIndividualLayoutConstraint *result;
45227 PyObject * obj0 = 0 ;
45228 char *kwnames[] = {
45229 (char *) "self", NULL
45230 };
45231
45232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45234 if (SWIG_arg_fail(1)) SWIG_fail;
45235 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45236
45237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45238 return resultobj;
45239 fail:
45240 return NULL;
45241 }
45242
45243
45244 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45245 PyObject *resultobj;
45246 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45247 wxIndividualLayoutConstraint *result;
45248 PyObject * obj0 = 0 ;
45249 char *kwnames[] = {
45250 (char *) "self", NULL
45251 };
45252
45253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45255 if (SWIG_arg_fail(1)) SWIG_fail;
45256 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45257
45258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45266 PyObject *resultobj;
45267 wxLayoutConstraints *result;
45268 char *kwnames[] = {
45269 NULL
45270 };
45271
45272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45273 {
45274 PyThreadState* __tstate = wxPyBeginAllowThreads();
45275 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45276
45277 wxPyEndAllowThreads(__tstate);
45278 if (PyErr_Occurred()) SWIG_fail;
45279 }
45280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45281 return resultobj;
45282 fail:
45283 return NULL;
45284 }
45285
45286
45287 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45288 PyObject *resultobj;
45289 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45290 wxWindow *arg2 = (wxWindow *) 0 ;
45291 int *arg3 = (int *) 0 ;
45292 bool result;
45293 int temp3 ;
45294 int res3 = 0 ;
45295 PyObject * obj0 = 0 ;
45296 PyObject * obj1 = 0 ;
45297 char *kwnames[] = {
45298 (char *) "self",(char *) "win", NULL
45299 };
45300
45301 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45304 if (SWIG_arg_fail(1)) SWIG_fail;
45305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45306 if (SWIG_arg_fail(2)) SWIG_fail;
45307 {
45308 PyThreadState* __tstate = wxPyBeginAllowThreads();
45309 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45310
45311 wxPyEndAllowThreads(__tstate);
45312 if (PyErr_Occurred()) SWIG_fail;
45313 }
45314 {
45315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45316 }
45317 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45318 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45319 return resultobj;
45320 fail:
45321 return NULL;
45322 }
45323
45324
45325 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45326 PyObject *resultobj;
45327 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45328 bool result;
45329 PyObject * obj0 = 0 ;
45330 char *kwnames[] = {
45331 (char *) "self", NULL
45332 };
45333
45334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45336 if (SWIG_arg_fail(1)) SWIG_fail;
45337 {
45338 PyThreadState* __tstate = wxPyBeginAllowThreads();
45339 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45340
45341 wxPyEndAllowThreads(__tstate);
45342 if (PyErr_Occurred()) SWIG_fail;
45343 }
45344 {
45345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45346 }
45347 return resultobj;
45348 fail:
45349 return NULL;
45350 }
45351
45352
45353 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45354 PyObject *obj;
45355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45356 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45357 Py_INCREF(obj);
45358 return Py_BuildValue((char *)"");
45359 }
45360 static PyMethodDef SwigMethods[] = {
45361 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45362 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45363 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45366 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45387 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45400 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45415 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45469 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45497 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45516 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45518 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45526 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45527 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45539 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45551 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45555 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45561 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45571 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45581 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45588 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45668 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45670 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45672 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45674 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45676 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45678 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45680 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45682 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45684 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45686 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45688 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45690 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45692 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45706 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45724 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45727 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45730 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45742 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45747 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45753 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45759 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45822 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45829 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45865 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45875 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45881 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45883 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45885 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45888 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45892 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45895 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45898 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45900 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45905 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45913 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45917 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45920 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45922 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45926 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45943 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45945 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45948 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45950 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45954 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45969 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45972 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45975 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45979 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45986 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45991 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45996 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46000 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46045 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46065 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46072 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46076 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46086 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46259 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46300 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46315 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46318 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46373 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46400 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46444 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46452 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46471 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46472 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46509 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46539 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46546 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46549 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46559 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46571 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46583 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46593 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46603 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46617 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46624 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46625 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46626 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46627 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46628 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46633 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46660 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46672 { NULL, NULL, 0, NULL }
46673 };
46674
46675
46676 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46677
46678 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46679 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46680 }
46681 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46682 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46683 }
46684 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46685 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46686 }
46687 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46688 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46689 }
46690 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46691 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46692 }
46693 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46694 return (void *)((wxSizer *) ((wxGridSizer *) x));
46695 }
46696 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46697 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46698 }
46699 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46700 return (void *)((wxSizer *) ((wxPySizer *) x));
46701 }
46702 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46703 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46704 }
46705 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46706 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46707 }
46708 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46709 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46710 }
46711 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46712 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46713 }
46714 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46715 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46716 }
46717 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46718 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46719 }
46720 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46721 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46722 }
46723 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46724 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46725 }
46726 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46727 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46728 }
46729 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46731 }
46732 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46733 return (void *)((wxEvent *) ((wxPyEvent *) x));
46734 }
46735 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46737 }
46738 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46739 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46740 }
46741 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46742 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46743 }
46744 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46745 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46746 }
46747 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46748 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46749 }
46750 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46751 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46752 }
46753 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46754 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46755 }
46756 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46757 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46758 }
46759 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46760 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46761 }
46762 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46763 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46764 }
46765 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46766 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46767 }
46768 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46769 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46770 }
46771 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46772 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46773 }
46774 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46775 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46776 }
46777 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46778 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46779 }
46780 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46781 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46782 }
46783 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46784 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46785 }
46786 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46787 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46788 }
46789 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46790 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46791 }
46792 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46793 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46794 }
46795 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46796 return (void *)((wxEvent *) ((wxShowEvent *) x));
46797 }
46798 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46799 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46800 }
46801 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46802 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46803 }
46804 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46805 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46806 }
46807 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46808 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46809 }
46810 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46811 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46812 }
46813 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46814 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46815 }
46816 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46817 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46818 }
46819 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46820 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46821 }
46822 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46823 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46824 }
46825 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46826 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46827 }
46828 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46829 return (void *)((wxControl *) ((wxControlWithItems *) x));
46830 }
46831 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46832 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46833 }
46834 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46835 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46836 }
46837 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46838 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46839 }
46840 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46841 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46842 }
46843 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46844 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46845 }
46846 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46847 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46848 }
46849 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46850 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46851 }
46852 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46853 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46854 }
46855 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46856 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46857 }
46858 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46859 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46860 }
46861 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46862 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46863 }
46864 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46865 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46866 }
46867 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46868 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46869 }
46870 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46871 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46872 }
46873 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46874 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46875 }
46876 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46877 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46878 }
46879 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46880 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46881 }
46882 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46883 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46884 }
46885 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46886 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46887 }
46888 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46889 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46890 }
46891 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46892 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46893 }
46894 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46895 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46896 }
46897 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46898 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46899 }
46900 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46901 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46902 }
46903 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46904 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46905 }
46906 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46907 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46908 }
46909 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46910 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46911 }
46912 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46913 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46914 }
46915 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46916 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46917 }
46918 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46919 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46920 }
46921 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46922 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46923 }
46924 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46925 return (void *)((wxObject *) ((wxSizerItem *) x));
46926 }
46927 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46928 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46929 }
46930 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46931 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46932 }
46933 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46934 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46935 }
46936 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46937 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46938 }
46939 static void *_p_wxSizerTo_p_wxObject(void *x) {
46940 return (void *)((wxObject *) ((wxSizer *) x));
46941 }
46942 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46943 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46944 }
46945 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46946 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46947 }
46948 static void *_p_wxEventTo_p_wxObject(void *x) {
46949 return (void *)((wxObject *) ((wxEvent *) x));
46950 }
46951 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46952 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46953 }
46954 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46955 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46956 }
46957 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46958 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46959 }
46960 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46961 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46962 }
46963 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46964 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46965 }
46966 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46967 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46968 }
46969 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46970 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46971 }
46972 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46973 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46974 }
46975 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46976 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46977 }
46978 static void *_p_wxControlTo_p_wxObject(void *x) {
46979 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46980 }
46981 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46982 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46983 }
46984 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46985 return (void *)((wxObject *) ((wxFSFile *) x));
46986 }
46987 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46988 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46989 }
46990 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46991 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46992 }
46993 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46994 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46995 }
46996 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46997 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46998 }
46999 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47000 return (void *)((wxObject *) ((wxMenuItem *) x));
47001 }
47002 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47003 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47004 }
47005 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47006 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47007 }
47008 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47009 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47010 }
47011 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47012 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47013 }
47014 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47015 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47016 }
47017 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47018 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47019 }
47020 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47021 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47022 }
47023 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47024 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47025 }
47026 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47027 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47028 }
47029 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47030 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47031 }
47032 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47033 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47034 }
47035 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47036 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47037 }
47038 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47039 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47040 }
47041 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47042 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47043 }
47044 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47045 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47046 }
47047 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47048 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47049 }
47050 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47051 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47052 }
47053 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47054 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47055 }
47056 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47057 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47058 }
47059 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47060 return (void *)((wxObject *) ((wxImageHandler *) x));
47061 }
47062 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47063 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47064 }
47065 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47066 return (void *)((wxObject *) ((wxEvtHandler *) x));
47067 }
47068 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47069 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47070 }
47071 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47072 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47073 }
47074 static void *_p_wxImageTo_p_wxObject(void *x) {
47075 return (void *)((wxObject *) ((wxImage *) x));
47076 }
47077 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47078 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47079 }
47080 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47081 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47082 }
47083 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47084 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47085 }
47086 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47087 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47088 }
47089 static void *_p_wxWindowTo_p_wxObject(void *x) {
47090 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47091 }
47092 static void *_p_wxMenuTo_p_wxObject(void *x) {
47093 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47094 }
47095 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47096 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47097 }
47098 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47099 return (void *)((wxObject *) ((wxFileSystem *) x));
47100 }
47101 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47102 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47103 }
47104 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47105 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47106 }
47107 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47108 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47109 }
47110 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47111 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47112 }
47113 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47114 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47115 }
47116 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47117 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47118 }
47119 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47120 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47121 }
47122 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47123 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47124 }
47125 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47126 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47127 }
47128 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47129 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47130 }
47131 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47132 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47133 }
47134 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47135 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47136 }
47137 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47138 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47139 }
47140 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47141 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47142 }
47143 static void *_p_wxControlTo_p_wxWindow(void *x) {
47144 return (void *)((wxWindow *) ((wxControl *) x));
47145 }
47146 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47147 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47148 }
47149 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47150 return (void *)((wxWindow *) ((wxMenuBar *) x));
47151 }
47152 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47153 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47154 }
47155 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47156 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47157 }
47158 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47159 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47160 }
47161 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47162 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47163 }
47164 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47165 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47166 }
47167 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47168 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47169 }
47170 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47171 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47172 }
47173 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47174 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47175 }
47176 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47177 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47178 }
47179 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47180 return (void *)((wxValidator *) ((wxPyValidator *) x));
47181 }
47182 static swig_type_info _swigt__p_wxLayoutConstraints[] = {{"_p_wxLayoutConstraints", 0, "wxLayoutConstraints *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47183 static swig_type_info _swigt__p_wxRealPoint[] = {{"_p_wxRealPoint", 0, "wxRealPoint *", 0, 0, 0, 0},{"_p_wxRealPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47184 static swig_type_info _swigt__p_wxSizerItem[] = {{"_p_wxSizerItem", 0, "wxSizerItem *", 0, 0, 0, 0},{"_p_wxSizerItem", 0, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxSizerItem, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47185 static swig_type_info _swigt__p_wxGBSizerItem[] = {{"_p_wxGBSizerItem", 0, "wxGBSizerItem *", 0, 0, 0, 0},{"_p_wxGBSizerItem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47186 static swig_type_info _swigt__p_wxScrollEvent[] = {{"_p_wxScrollEvent", 0, "wxScrollEvent *", 0, 0, 0, 0},{"_p_wxScrollEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47187 static swig_type_info _swigt__p_wxEventLoop[] = {{"_p_wxEventLoop", 0, "wxEventLoop *", 0, 0, 0, 0},{"_p_wxEventLoop", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47188 static swig_type_info _swigt__p_wxIndividualLayoutConstraint[] = {{"_p_wxIndividualLayoutConstraint", 0, "wxIndividualLayoutConstraint *", 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47189 static swig_type_info _swigt__p_wxSizer[] = {{"_p_wxSizer", 0, "wxSizer *", 0, 0, 0, 0},{"_p_wxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxSizer, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47190 static swig_type_info _swigt__p_wxBoxSizer[] = {{"_p_wxBoxSizer", 0, "wxBoxSizer *", 0, 0, 0, 0},{"_p_wxBoxSizer", 0, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxBoxSizer, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxBoxSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47191 static swig_type_info _swigt__p_wxStaticBoxSizer[] = {{"_p_wxStaticBoxSizer", 0, "wxStaticBoxSizer *", 0, 0, 0, 0},{"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47192 static swig_type_info _swigt__p_wxGridBagSizer[] = {{"_p_wxGridBagSizer", 0, "wxGridBagSizer *", 0, 0, 0, 0},{"_p_wxGridBagSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47193 static swig_type_info _swigt__p_wxAcceleratorEntry[] = {{"_p_wxAcceleratorEntry", 0, "wxAcceleratorEntry *", 0, 0, 0, 0},{"_p_wxAcceleratorEntry", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47194 static swig_type_info _swigt__p_wxUpdateUIEvent[] = {{"_p_wxUpdateUIEvent", 0, "wxUpdateUIEvent *", 0, 0, 0, 0},{"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47195 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47196 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47197 static swig_type_info _swigt__p_wxMenu[] = {{"_p_wxMenu", 0, "wxMenu *", 0, 0, 0, 0},{"_p_wxMenu", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47198 static swig_type_info _swigt__p_wxGridSizer[] = {{"_p_wxGridSizer", 0, "wxGridSizer *", 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxGridSizer, 0, 0, 0, 0, 0},{"_p_wxGridSizer", 0, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxGridSizer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47199 static swig_type_info _swigt__p_wxFlexGridSizer[] = {{"_p_wxFlexGridSizer", 0, "wxFlexGridSizer *", 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxFlexGridSizer, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47200 static swig_type_info _swigt__p_wxInitDialogEvent[] = {{"_p_wxInitDialogEvent", 0, "wxInitDialogEvent *", 0, 0, 0, 0},{"_p_wxInitDialogEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47201 static swig_type_info _swigt__p_wxItemContainer[] = {{"_p_wxItemContainer", 0, "wxItemContainer *", 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0, 0, 0, 0},{"_p_wxItemContainer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47202 static swig_type_info _swigt__p_wxNcPaintEvent[] = {{"_p_wxNcPaintEvent", 0, "wxNcPaintEvent *", 0, 0, 0, 0},{"_p_wxNcPaintEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47203 static swig_type_info _swigt__p_wxPaintEvent[] = {{"_p_wxPaintEvent", 0, "wxPaintEvent *", 0, 0, 0, 0},{"_p_wxPaintEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47204 static swig_type_info _swigt__p_wxSysColourChangedEvent[] = {{"_p_wxSysColourChangedEvent", 0, "wxSysColourChangedEvent *", 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47205 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent[] = {{"_p_wxMouseCaptureChangedEvent", 0, "wxMouseCaptureChangedEvent *", 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47206 static swig_type_info _swigt__p_wxDisplayChangedEvent[] = {{"_p_wxDisplayChangedEvent", 0, "wxDisplayChangedEvent *", 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47207 static swig_type_info _swigt__p_wxPaletteChangedEvent[] = {{"_p_wxPaletteChangedEvent", 0, "wxPaletteChangedEvent *", 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47208 static swig_type_info _swigt__p_wxControl[] = {{"_p_wxControl", 0, "wxControl *", 0, 0, 0, 0},{"_p_wxControl", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxControl, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47209 static swig_type_info _swigt__p_wxFont[] = {{"_p_wxFont", 0, "wxFont *", 0, 0, 0, 0},{"_p_wxFont", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47210 static swig_type_info _swigt__p_wxMenuBarBase[] = {{"_p_wxMenuBarBase", 0, "wxMenuBarBase *", 0, 0, 0, 0},{"_p_wxMenuBarBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47211 static swig_type_info _swigt__p_wxSetCursorEvent[] = {{"_p_wxSetCursorEvent", 0, "wxSetCursorEvent *", 0, 0, 0, 0},{"_p_wxSetCursorEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47212 static swig_type_info _swigt__p_wxFSFile[] = {{"_p_wxFSFile", 0, "wxFSFile *", 0, 0, 0, 0},{"_p_wxFSFile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47213 static swig_type_info _swigt__p_wxCaret[] = {{"_p_wxCaret", 0, "wxCaret *", 0, 0, 0, 0},{"_p_wxCaret", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47214 static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47215 static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47216 static swig_type_info _swigt__p_wxRegion[] = {{"_p_wxRegion", 0, "wxRegion *", 0, 0, 0, 0},{"_p_wxRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47217 static swig_type_info _swigt__p_wxPoint2D[] = {{"_p_wxPoint2D", 0, "wxPoint2D *", 0, 0, 0, 0},{"_p_wxPoint2D", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47218 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47219 static swig_type_info _swigt__p_wxSize[] = {{"_p_wxSize", 0, "wxSize *", 0, 0, 0, 0},{"_p_wxSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47220 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47221 static swig_type_info _swigt__p_wxPySizer[] = {{"_p_wxPySizer", 0, "wxPySizer *", 0, 0, 0, 0},{"_p_wxPySizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47222 static swig_type_info _swigt__p_wxVisualAttributes[] = {{"_p_wxVisualAttributes", 0, "wxVisualAttributes *", 0, 0, 0, 0},{"_p_wxVisualAttributes", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47223 static swig_type_info _swigt__p_wxNotifyEvent[] = {{"_p_wxNotifyEvent", 0, "wxNotifyEvent *", 0, 0, 0, 0},{"_p_wxNotifyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47224 static swig_type_info _swigt__p_wxPyEvent[] = {{"_p_wxPyEvent", 0, "wxPyEvent *", 0, 0, 0, 0},{"_p_wxPyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47225 static swig_type_info _swigt__p_wxPropagationDisabler[] = {{"_p_wxPropagationDisabler", 0, "wxPropagationDisabler *", 0, 0, 0, 0},{"_p_wxPropagationDisabler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47226 static swig_type_info _swigt__p_form_ops_t[] = {{"_p_form_ops_t", 0, "enum form_ops_t *|form_ops_t *", 0, 0, 0, 0},{"_p_form_ops_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47227 static swig_type_info _swigt__p_wxAppTraits[] = {{"_p_wxAppTraits", 0, "wxAppTraits *", 0, 0, 0, 0},{"_p_wxAppTraits", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47228 static swig_type_info _swigt__p_wxArrayString[] = {{"_p_wxArrayString", 0, "wxArrayString *", 0, 0, 0, 0},{"_p_wxArrayString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47229 static swig_type_info _swigt__p_wxShowEvent[] = {{"_p_wxShowEvent", 0, "wxShowEvent *", 0, 0, 0, 0},{"_p_wxShowEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47230 static swig_type_info _swigt__p_wxToolTip[] = {{"_p_wxToolTip", 0, "wxToolTip *", 0, 0, 0, 0},{"_p_wxToolTip", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47231 static swig_type_info _swigt__p_wxMoveEvent[] = {{"_p_wxMoveEvent", 0, "wxMoveEvent *", 0, 0, 0, 0},{"_p_wxMoveEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47232 static swig_type_info _swigt__p_wxSizeEvent[] = {{"_p_wxSizeEvent", 0, "wxSizeEvent *", 0, 0, 0, 0},{"_p_wxSizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47233 static swig_type_info _swigt__p_wxActivateEvent[] = {{"_p_wxActivateEvent", 0, "wxActivateEvent *", 0, 0, 0, 0},{"_p_wxActivateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47234 static swig_type_info _swigt__p_wxIconizeEvent[] = {{"_p_wxIconizeEvent", 0, "wxIconizeEvent *", 0, 0, 0, 0},{"_p_wxIconizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47235 static swig_type_info _swigt__p_wxMaximizeEvent[] = {{"_p_wxMaximizeEvent", 0, "wxMaximizeEvent *", 0, 0, 0, 0},{"_p_wxMaximizeEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47236 static swig_type_info _swigt__p_wxQueryNewPaletteEvent[] = {{"_p_wxQueryNewPaletteEvent", 0, "wxQueryNewPaletteEvent *", 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47237 static swig_type_info _swigt__p_wxWindowCreateEvent[] = {{"_p_wxWindowCreateEvent", 0, "wxWindowCreateEvent *", 0, 0, 0, 0},{"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47238 static swig_type_info _swigt__p_wxIdleEvent[] = {{"_p_wxIdleEvent", 0, "wxIdleEvent *", 0, 0, 0, 0},{"_p_wxIdleEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47239 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47240 static swig_type_info _swigt__p_wxMenuItem[] = {{"_p_wxMenuItem", 0, "wxMenuItem *", 0, 0, 0, 0},{"_p_wxMenuItem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47241 static swig_type_info _swigt__p_wxStaticBox[] = {{"_p_wxStaticBox", 0, "wxStaticBox *", 0, 0, 0, 0},{"_p_wxStaticBox", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47242 static swig_type_info _swigt__p_long[] = {{"_p_long", 0, "long *", 0, 0, 0, 0},{"_p_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47243 static swig_type_info _swigt__p_wxDuplexMode[] = {{"_p_wxDuplexMode", 0, "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0, 0},{"_p_wxDuplexMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47244 static swig_type_info _swigt__p_wxTIFFHandler[] = {{"_p_wxTIFFHandler", 0, "wxTIFFHandler *", 0, 0, 0, 0},{"_p_wxTIFFHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47245 static swig_type_info _swigt__p_wxXPMHandler[] = {{"_p_wxXPMHandler", 0, "wxXPMHandler *", 0, 0, 0, 0},{"_p_wxXPMHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47246 static swig_type_info _swigt__p_wxPNMHandler[] = {{"_p_wxPNMHandler", 0, "wxPNMHandler *", 0, 0, 0, 0},{"_p_wxPNMHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47247 static swig_type_info _swigt__p_wxJPEGHandler[] = {{"_p_wxJPEGHandler", 0, "wxJPEGHandler *", 0, 0, 0, 0},{"_p_wxJPEGHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47248 static swig_type_info _swigt__p_wxPCXHandler[] = {{"_p_wxPCXHandler", 0, "wxPCXHandler *", 0, 0, 0, 0},{"_p_wxPCXHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47249 static swig_type_info _swigt__p_wxGIFHandler[] = {{"_p_wxGIFHandler", 0, "wxGIFHandler *", 0, 0, 0, 0},{"_p_wxGIFHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47250 static swig_type_info _swigt__p_wxPNGHandler[] = {{"_p_wxPNGHandler", 0, "wxPNGHandler *", 0, 0, 0, 0},{"_p_wxPNGHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47251 static swig_type_info _swigt__p_wxANIHandler[] = {{"_p_wxANIHandler", 0, "wxANIHandler *", 0, 0, 0, 0},{"_p_wxANIHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47252 static swig_type_info _swigt__p_wxMemoryFSHandler[] = {{"_p_wxMemoryFSHandler", 0, "wxMemoryFSHandler *", 0, 0, 0, 0},{"_p_wxMemoryFSHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47253 static swig_type_info _swigt__p_wxZipFSHandler[] = {{"_p_wxZipFSHandler", 0, "wxZipFSHandler *", 0, 0, 0, 0},{"_p_wxZipFSHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47254 static swig_type_info _swigt__p_wxInternetFSHandler[] = {{"_p_wxInternetFSHandler", 0, "wxInternetFSHandler *", 0, 0, 0, 0},{"_p_wxInternetFSHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47255 static swig_type_info _swigt__p_wxPyFileSystemHandler[] = {{"_p_wxPyFileSystemHandler", 0, "wxPyFileSystemHandler *", 0, 0, 0, 0},{"_p_wxPyFileSystemHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47256 static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47257 static swig_type_info _swigt__p_wxCURHandler[] = {{"_p_wxCURHandler", 0, "wxCURHandler *", 0, 0, 0, 0},{"_p_wxCURHandler", 0, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxCURHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47258 static swig_type_info _swigt__p_wxICOHandler[] = {{"_p_wxICOHandler", 0, "wxICOHandler *", 0, 0, 0, 0},{"_p_wxICOHandler", 0, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxICOHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxICOHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47259 static swig_type_info _swigt__p_wxBMPHandler[] = {{"_p_wxBMPHandler", 0, "wxBMPHandler *", 0, 0, 0, 0},{"_p_wxBMPHandler", 0, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxBMPHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxBMPHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxBMPHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47260 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47261 static swig_type_info _swigt__p_wxFileSystemHandler[] = {{"_p_wxFileSystemHandler", 0, "wxFileSystemHandler *", 0, 0, 0, 0},{"_p_wxFileSystemHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyFileSystemHandler", _p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{"_p_wxInternetFSHandler", _p_wxInternetFSHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{"_p_wxZipFSHandler", _p_wxZipFSHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{"_p_wxMemoryFSHandler", _p_wxMemoryFSHandlerTo_p_wxFileSystemHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47262 static swig_type_info _swigt__p_wxRect[] = {{"_p_wxRect", 0, "wxRect *", 0, 0, 0, 0},{"_p_wxRect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47263 static swig_type_info _swigt__p_wxButton[] = {{"_p_wxButton", 0, "wxButton *", 0, 0, 0, 0},{"_p_wxButton", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47264 static swig_type_info _swigt__p_wxGBSpan[] = {{"_p_wxGBSpan", 0, "wxGBSpan *", 0, 0, 0, 0},{"_p_wxGBSpan", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47265 static swig_type_info _swigt__p_wxPropagateOnce[] = {{"_p_wxPropagateOnce", 0, "wxPropagateOnce *", 0, 0, 0, 0},{"_p_wxPropagateOnce", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47266 static swig_type_info _swigt__p_wxAcceleratorTable[] = {{"_p_wxAcceleratorTable", 0, "wxAcceleratorTable *", 0, 0, 0, 0},{"_p_wxAcceleratorTable", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47267 static swig_type_info _swigt__p_wxStdDialogButtonSizer[] = {{"_p_wxStdDialogButtonSizer", 0, "wxStdDialogButtonSizer *", 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47268 static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47269 static swig_type_info _swigt__p_wxGBPosition[] = {{"_p_wxGBPosition", 0, "wxGBPosition *", 0, 0, 0, 0},{"_p_wxGBPosition", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47270 static swig_type_info _swigt__p_wxImage[] = {{"_p_wxImage", 0, "wxImage *", 0, 0, 0, 0},{"_p_wxImage", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47271 static swig_type_info _swigt__p_wxFrame[] = {{"_p_wxFrame", 0, "wxFrame *", 0, 0, 0, 0},{"_p_wxFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47272 static swig_type_info _swigt__p_wxScrollWinEvent[] = {{"_p_wxScrollWinEvent", 0, "wxScrollWinEvent *", 0, 0, 0, 0},{"_p_wxScrollWinEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47273 static swig_type_info _swigt__p_wxPaperSize[] = {{"_p_wxPaperSize", 0, "enum wxPaperSize *|wxPaperSize *", 0, 0, 0, 0},{"_p_wxPaperSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47274 static swig_type_info _swigt__p_wxImageHistogram[] = {{"_p_wxImageHistogram", 0, "wxImageHistogram *", 0, 0, 0, 0},{"_p_wxImageHistogram", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47275 static swig_type_info _swigt__p_wxPoint[] = {{"_p_wxPoint", 0, "wxPoint *", 0, 0, 0, 0},{"_p_wxPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47276 static swig_type_info _swigt__p_wxCursor[] = {{"_p_wxCursor", 0, "wxCursor *", 0, 0, 0, 0},{"_p_wxCursor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47277 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47278 static swig_type_info _swigt__p_wxInputStream[] = {{"_p_wxInputStream", 0, "wxInputStream *", 0, 0, 0, 0},{"_p_wxInputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47279 static swig_type_info _swigt__p_wxOutputStream[] = {{"_p_wxOutputStream", 0, "wxOutputStream *", 0, 0, 0, 0},{"_p_wxOutputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47280 static swig_type_info _swigt__p_wxPyInputStream[] = {{"_p_wxPyInputStream", 0, "wxPyInputStream *", 0, 0, 0, 0},{"_p_wxPyInputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47281 static swig_type_info _swigt__p_wxDateTime[] = {{"_p_wxDateTime", 0, "wxDateTime *", 0, 0, 0, 0},{"_p_wxDateTime", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47282 static swig_type_info _swigt__p_wxKeyEvent[] = {{"_p_wxKeyEvent", 0, "wxKeyEvent *", 0, 0, 0, 0},{"_p_wxKeyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47283 static swig_type_info _swigt__p_wxNavigationKeyEvent[] = {{"_p_wxNavigationKeyEvent", 0, "wxNavigationKeyEvent *", 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47284 static swig_type_info _swigt__p_wxWindowDestroyEvent[] = {{"_p_wxWindowDestroyEvent", 0, "wxWindowDestroyEvent *", 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47285 static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|wxUIntPtr *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47286 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47287 static swig_type_info _swigt__p_wxMenuBar[] = {{"_p_wxMenuBar", 0, "wxMenuBar *", 0, 0, 0, 0},{"_p_wxMenuBar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47288 static swig_type_info _swigt__p_wxFileSystem[] = {{"_p_wxFileSystem", 0, "wxFileSystem *", 0, 0, 0, 0},{"_p_wxFileSystem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47289 static swig_type_info _swigt__p_wxBitmap[] = {{"_p_wxBitmap", 0, "wxBitmap *", 0, 0, 0, 0},{"_p_wxBitmap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47290 static swig_type_info _swigt__unsigned_int[] = {{"_unsigned_int", 0, "unsigned int|std::size_t", 0, 0, 0, 0},{"_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47291 static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *|time_t *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47292 static swig_type_info _swigt__p_wxMenuEvent[] = {{"_p_wxMenuEvent", 0, "wxMenuEvent *", 0, 0, 0, 0},{"_p_wxMenuEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47293 static swig_type_info _swigt__p_wxContextMenuEvent[] = {{"_p_wxContextMenuEvent", 0, "wxContextMenuEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47294 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47295 static swig_type_info _swigt__p_wxEraseEvent[] = {{"_p_wxEraseEvent", 0, "wxEraseEvent *", 0, 0, 0, 0},{"_p_wxEraseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47296 static swig_type_info _swigt__p_wxMouseEvent[] = {{"_p_wxMouseEvent", 0, "wxMouseEvent *", 0, 0, 0, 0},{"_p_wxMouseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47297 static swig_type_info _swigt__p_wxCloseEvent[] = {{"_p_wxCloseEvent", 0, "wxCloseEvent *", 0, 0, 0, 0},{"_p_wxCloseEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47298 static swig_type_info _swigt__p_wxPyApp[] = {{"_p_wxPyApp", 0, "wxPyApp *", 0, 0, 0, 0},{"_p_wxPyApp", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47299 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47300 static swig_type_info _swigt__p_wxPyCommandEvent[] = {{"_p_wxPyCommandEvent", 0, "wxPyCommandEvent *", 0, 0, 0, 0},{"_p_wxPyCommandEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47301 static swig_type_info _swigt__p_wxPyDropTarget[] = {{"_p_wxPyDropTarget", 0, "wxPyDropTarget *", 0, 0, 0, 0},{"_p_wxPyDropTarget", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47302 static swig_type_info _swigt__p_wxQuantize[] = {{"_p_wxQuantize", 0, "wxQuantize *", 0, 0, 0, 0},{"_p_wxQuantize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47303 static swig_type_info _swigt__p_wxFocusEvent[] = {{"_p_wxFocusEvent", 0, "wxFocusEvent *", 0, 0, 0, 0},{"_p_wxFocusEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47304 static swig_type_info _swigt__p_wxChildFocusEvent[] = {{"_p_wxChildFocusEvent", 0, "wxChildFocusEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47305 static swig_type_info _swigt__p_wxDropFilesEvent[] = {{"_p_wxDropFilesEvent", 0, "wxDropFilesEvent *", 0, 0, 0, 0},{"_p_wxDropFilesEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47306 static swig_type_info _swigt__p_wxControlWithItems[] = {{"_p_wxControlWithItems", 0, "wxControlWithItems *", 0, 0, 0, 0},{"_p_wxControlWithItems", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47307 static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0, 0, 0, 0},{"_p_wxColour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47308 static swig_type_info _swigt__p_wxValidator[] = {{"_p_wxValidator", 0, "wxValidator *", 0, 0, 0, 0},{"_p_wxValidator", 0, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxValidator, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47309 static swig_type_info _swigt__p_wxPyValidator[] = {{"_p_wxPyValidator", 0, "wxPyValidator *", 0, 0, 0, 0},{"_p_wxPyValidator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47310
47311 static swig_type_info *swig_types_initial[] = {
47312 _swigt__p_wxLayoutConstraints,
47313 _swigt__p_wxRealPoint,
47314 _swigt__p_wxSizerItem,
47315 _swigt__p_wxGBSizerItem,
47316 _swigt__p_wxScrollEvent,
47317 _swigt__p_wxEventLoop,
47318 _swigt__p_wxIndividualLayoutConstraint,
47319 _swigt__p_wxSizer,
47320 _swigt__p_wxBoxSizer,
47321 _swigt__p_wxStaticBoxSizer,
47322 _swigt__p_wxGridBagSizer,
47323 _swigt__p_wxAcceleratorEntry,
47324 _swigt__p_wxUpdateUIEvent,
47325 _swigt__p_wxEvent,
47326 _swigt__p_buffer,
47327 _swigt__p_wxMenu,
47328 _swigt__p_wxGridSizer,
47329 _swigt__p_wxFlexGridSizer,
47330 _swigt__p_wxInitDialogEvent,
47331 _swigt__p_wxItemContainer,
47332 _swigt__p_wxNcPaintEvent,
47333 _swigt__p_wxPaintEvent,
47334 _swigt__p_wxSysColourChangedEvent,
47335 _swigt__p_wxMouseCaptureChangedEvent,
47336 _swigt__p_wxDisplayChangedEvent,
47337 _swigt__p_wxPaletteChangedEvent,
47338 _swigt__p_wxControl,
47339 _swigt__p_wxFont,
47340 _swigt__p_wxMenuBarBase,
47341 _swigt__p_wxSetCursorEvent,
47342 _swigt__p_wxFSFile,
47343 _swigt__p_wxCaret,
47344 _swigt__ptrdiff_t,
47345 _swigt__std__ptrdiff_t,
47346 _swigt__p_wxRegion,
47347 _swigt__p_wxPoint2D,
47348 _swigt__p_int,
47349 _swigt__p_wxSize,
47350 _swigt__p_wxDC,
47351 _swigt__p_wxPySizer,
47352 _swigt__p_wxVisualAttributes,
47353 _swigt__p_wxNotifyEvent,
47354 _swigt__p_wxPyEvent,
47355 _swigt__p_wxPropagationDisabler,
47356 _swigt__p_form_ops_t,
47357 _swigt__p_wxAppTraits,
47358 _swigt__p_wxArrayString,
47359 _swigt__p_wxShowEvent,
47360 _swigt__p_wxToolTip,
47361 _swigt__p_wxMoveEvent,
47362 _swigt__p_wxSizeEvent,
47363 _swigt__p_wxActivateEvent,
47364 _swigt__p_wxIconizeEvent,
47365 _swigt__p_wxMaximizeEvent,
47366 _swigt__p_wxQueryNewPaletteEvent,
47367 _swigt__p_wxWindowCreateEvent,
47368 _swigt__p_wxIdleEvent,
47369 _swigt__p_wxDateEvent,
47370 _swigt__p_wxMenuItem,
47371 _swigt__p_wxStaticBox,
47372 _swigt__p_long,
47373 _swigt__p_wxDuplexMode,
47374 _swigt__p_wxTIFFHandler,
47375 _swigt__p_wxXPMHandler,
47376 _swigt__p_wxPNMHandler,
47377 _swigt__p_wxJPEGHandler,
47378 _swigt__p_wxPCXHandler,
47379 _swigt__p_wxGIFHandler,
47380 _swigt__p_wxPNGHandler,
47381 _swigt__p_wxANIHandler,
47382 _swigt__p_wxMemoryFSHandler,
47383 _swigt__p_wxZipFSHandler,
47384 _swigt__p_wxInternetFSHandler,
47385 _swigt__p_wxPyFileSystemHandler,
47386 _swigt__p_wxEvtHandler,
47387 _swigt__p_wxCURHandler,
47388 _swigt__p_wxICOHandler,
47389 _swigt__p_wxBMPHandler,
47390 _swigt__p_wxImageHandler,
47391 _swigt__p_wxFileSystemHandler,
47392 _swigt__p_wxRect,
47393 _swigt__p_wxButton,
47394 _swigt__p_wxGBSpan,
47395 _swigt__p_wxPropagateOnce,
47396 _swigt__p_wxAcceleratorTable,
47397 _swigt__p_wxStdDialogButtonSizer,
47398 _swigt__p_char,
47399 _swigt__p_wxGBPosition,
47400 _swigt__p_wxImage,
47401 _swigt__p_wxFrame,
47402 _swigt__p_wxScrollWinEvent,
47403 _swigt__p_wxPaperSize,
47404 _swigt__p_wxImageHistogram,
47405 _swigt__p_wxPoint,
47406 _swigt__p_wxCursor,
47407 _swigt__p_wxObject,
47408 _swigt__p_wxInputStream,
47409 _swigt__p_wxOutputStream,
47410 _swigt__p_wxPyInputStream,
47411 _swigt__p_wxDateTime,
47412 _swigt__p_wxKeyEvent,
47413 _swigt__p_wxNavigationKeyEvent,
47414 _swigt__p_wxWindowDestroyEvent,
47415 _swigt__p_unsigned_long,
47416 _swigt__p_wxWindow,
47417 _swigt__p_wxMenuBar,
47418 _swigt__p_wxFileSystem,
47419 _swigt__p_wxBitmap,
47420 _swigt__unsigned_int,
47421 _swigt__p_unsigned_int,
47422 _swigt__p_wxMenuEvent,
47423 _swigt__p_wxContextMenuEvent,
47424 _swigt__p_unsigned_char,
47425 _swigt__p_wxEraseEvent,
47426 _swigt__p_wxMouseEvent,
47427 _swigt__p_wxCloseEvent,
47428 _swigt__p_wxPyApp,
47429 _swigt__p_wxCommandEvent,
47430 _swigt__p_wxPyCommandEvent,
47431 _swigt__p_wxPyDropTarget,
47432 _swigt__p_wxQuantize,
47433 _swigt__p_wxFocusEvent,
47434 _swigt__p_wxChildFocusEvent,
47435 _swigt__p_wxDropFilesEvent,
47436 _swigt__p_wxControlWithItems,
47437 _swigt__p_wxColour,
47438 _swigt__p_wxValidator,
47439 _swigt__p_wxPyValidator,
47440 0
47441 };
47442
47443
47444 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47445
47446 static swig_const_info swig_const_table[] = {
47447 {0, 0, 0, 0.0, 0, 0}};
47448
47449 #ifdef __cplusplus
47450 }
47451 #endif
47452
47453
47454 #ifdef __cplusplus
47455 extern "C" {
47456 #endif
47457
47458 /* Python-specific SWIG API */
47459 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47460 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47461 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47462
47463 /* -----------------------------------------------------------------------------
47464 * global variable support code.
47465 * ----------------------------------------------------------------------------- */
47466
47467 typedef struct swig_globalvar {
47468 char *name; /* Name of global variable */
47469 PyObject *(*get_attr)(); /* Return the current value */
47470 int (*set_attr)(PyObject *); /* Set the value */
47471 struct swig_globalvar *next;
47472 } swig_globalvar;
47473
47474 typedef struct swig_varlinkobject {
47475 PyObject_HEAD
47476 swig_globalvar *vars;
47477 } swig_varlinkobject;
47478
47479 static PyObject *
47480 swig_varlink_repr(swig_varlinkobject *v) {
47481 v = v;
47482 return PyString_FromString("<Swig global variables>");
47483 }
47484
47485 static int
47486 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47487 swig_globalvar *var;
47488 flags = flags;
47489 fprintf(fp,"Swig global variables { ");
47490 for (var = v->vars; var; var=var->next) {
47491 fprintf(fp,"%s", var->name);
47492 if (var->next) fprintf(fp,", ");
47493 }
47494 fprintf(fp," }\n");
47495 return 0;
47496 }
47497
47498 static PyObject *
47499 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47500 swig_globalvar *var = v->vars;
47501 while (var) {
47502 if (strcmp(var->name,n) == 0) {
47503 return (*var->get_attr)();
47504 }
47505 var = var->next;
47506 }
47507 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47508 return NULL;
47509 }
47510
47511 static int
47512 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47513 swig_globalvar *var = v->vars;
47514 while (var) {
47515 if (strcmp(var->name,n) == 0) {
47516 return (*var->set_attr)(p);
47517 }
47518 var = var->next;
47519 }
47520 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47521 return 1;
47522 }
47523
47524 static PyTypeObject varlinktype = {
47525 PyObject_HEAD_INIT(0)
47526 0, /* Number of items in variable part (ob_size) */
47527 (char *)"swigvarlink", /* Type name (tp_name) */
47528 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47529 0, /* Itemsize (tp_itemsize) */
47530 0, /* Deallocator (tp_dealloc) */
47531 (printfunc) swig_varlink_print, /* Print (tp_print) */
47532 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47533 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47534 0, /* tp_compare */
47535 (reprfunc) swig_varlink_repr, /* tp_repr */
47536 0, /* tp_as_number */
47537 0, /* tp_as_sequence */
47538 0, /* tp_as_mapping */
47539 0, /* tp_hash */
47540 0, /* tp_call */
47541 0, /* tp_str */
47542 0, /* tp_getattro */
47543 0, /* tp_setattro */
47544 0, /* tp_as_buffer */
47545 0, /* tp_flags */
47546 0, /* tp_doc */
47547 #if PY_VERSION_HEX >= 0x02000000
47548 0, /* tp_traverse */
47549 0, /* tp_clear */
47550 #endif
47551 #if PY_VERSION_HEX >= 0x02010000
47552 0, /* tp_richcompare */
47553 0, /* tp_weaklistoffset */
47554 #endif
47555 #if PY_VERSION_HEX >= 0x02020000
47556 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47557 #endif
47558 #if PY_VERSION_HEX >= 0x02030000
47559 0, /* tp_del */
47560 #endif
47561 #ifdef COUNT_ALLOCS
47562 0,0,0,0 /* tp_alloc -> tp_next */
47563 #endif
47564 };
47565
47566 /* Create a variable linking object for use later */
47567 static PyObject *
47568 SWIG_Python_newvarlink(void) {
47569 swig_varlinkobject *result = 0;
47570 result = PyMem_NEW(swig_varlinkobject,1);
47571 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47572 result->ob_type = &varlinktype;
47573 result->vars = 0;
47574 result->ob_refcnt = 0;
47575 Py_XINCREF((PyObject *) result);
47576 return ((PyObject*) result);
47577 }
47578
47579 static void
47580 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47581 swig_varlinkobject *v;
47582 swig_globalvar *gv;
47583 v= (swig_varlinkobject *) p;
47584 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47585 gv->name = (char *) malloc(strlen(name)+1);
47586 strcpy(gv->name,name);
47587 gv->get_attr = get_attr;
47588 gv->set_attr = set_attr;
47589 gv->next = v->vars;
47590 v->vars = gv;
47591 }
47592
47593 /* -----------------------------------------------------------------------------
47594 * constants/methods manipulation
47595 * ----------------------------------------------------------------------------- */
47596
47597 /* Install Constants */
47598 static void
47599 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47600 PyObject *obj = 0;
47601 size_t i;
47602 for (i = 0; constants[i].type; i++) {
47603 switch(constants[i].type) {
47604 case SWIG_PY_INT:
47605 obj = PyInt_FromLong(constants[i].lvalue);
47606 break;
47607 case SWIG_PY_FLOAT:
47608 obj = PyFloat_FromDouble(constants[i].dvalue);
47609 break;
47610 case SWIG_PY_STRING:
47611 if (constants[i].pvalue) {
47612 obj = PyString_FromString((char *) constants[i].pvalue);
47613 } else {
47614 Py_INCREF(Py_None);
47615 obj = Py_None;
47616 }
47617 break;
47618 case SWIG_PY_POINTER:
47619 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47620 break;
47621 case SWIG_PY_BINARY:
47622 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47623 break;
47624 default:
47625 obj = 0;
47626 break;
47627 }
47628 if (obj) {
47629 PyDict_SetItemString(d,constants[i].name,obj);
47630 Py_DECREF(obj);
47631 }
47632 }
47633 }
47634
47635 /* -----------------------------------------------------------------------------*/
47636 /* Fix SwigMethods to carry the callback ptrs when needed */
47637 /* -----------------------------------------------------------------------------*/
47638
47639 static void
47640 SWIG_Python_FixMethods(PyMethodDef *methods,
47641 swig_const_info *const_table,
47642 swig_type_info **types,
47643 swig_type_info **types_initial) {
47644 size_t i;
47645 for (i = 0; methods[i].ml_name; ++i) {
47646 char *c = methods[i].ml_doc;
47647 if (c && (c = strstr(c, "swig_ptr: "))) {
47648 int j;
47649 swig_const_info *ci = 0;
47650 char *name = c + 10;
47651 for (j = 0; const_table[j].type; j++) {
47652 if (strncmp(const_table[j].name, name,
47653 strlen(const_table[j].name)) == 0) {
47654 ci = &(const_table[j]);
47655 break;
47656 }
47657 }
47658 if (ci) {
47659 size_t shift = (ci->ptype) - types;
47660 swig_type_info *ty = types_initial[shift];
47661 size_t ldoc = (c - methods[i].ml_doc);
47662 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47663 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47664 char *buff = ndoc;
47665 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47666 strncpy(buff, methods[i].ml_doc, ldoc);
47667 buff += ldoc;
47668 strncpy(buff, "swig_ptr: ", 10);
47669 buff += 10;
47670 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47671 methods[i].ml_doc = ndoc;
47672 }
47673 }
47674 }
47675 }
47676
47677 /* -----------------------------------------------------------------------------*
47678 * Initialize type list
47679 * -----------------------------------------------------------------------------*/
47680
47681 #if PY_MAJOR_VERSION < 2
47682 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47683 is copied out of Python/modsupport.c in python version 2.3.4 */
47684 static int
47685 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47686 {
47687 PyObject *dict;
47688 if (!PyModule_Check(m)) {
47689 PyErr_SetString(PyExc_TypeError,
47690 "PyModule_AddObject() needs module as first arg");
47691 return -1;
47692 }
47693 if (!o) {
47694 PyErr_SetString(PyExc_TypeError,
47695 "PyModule_AddObject() needs non-NULL value");
47696 return -1;
47697 }
47698
47699 dict = PyModule_GetDict(m);
47700 if (dict == NULL) {
47701 /* Internal error -- modules must have a dict! */
47702 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47703 PyModule_GetName(m));
47704 return -1;
47705 }
47706 if (PyDict_SetItemString(dict, name, o))
47707 return -1;
47708 Py_DECREF(o);
47709 return 0;
47710 }
47711 #endif
47712
47713 static swig_type_info **
47714 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47715 static PyMethodDef swig_empty_runtime_method_table[] = {
47716 {
47717 NULL, NULL, 0, NULL
47718 }
47719 };/* Sentinel */
47720
47721 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47722 swig_empty_runtime_method_table);
47723 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47724 if (pointer && module) {
47725 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47726 }
47727 return type_list_handle;
47728 }
47729
47730 static swig_type_info **
47731 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47732 swig_type_info **type_pointer;
47733
47734 /* first check if module already created */
47735 type_pointer = SWIG_Python_GetTypeListHandle();
47736 if (type_pointer) {
47737 return type_pointer;
47738 } else {
47739 /* create a new module and variable */
47740 return SWIG_Python_SetTypeListHandle(type_list_handle);
47741 }
47742 }
47743
47744 #ifdef __cplusplus
47745 }
47746 #endif
47747
47748 /* -----------------------------------------------------------------------------*
47749 * Partial Init method
47750 * -----------------------------------------------------------------------------*/
47751
47752 #ifdef SWIG_LINK_RUNTIME
47753 #ifdef __cplusplus
47754 extern "C"
47755 #endif
47756 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47757 #endif
47758
47759 #ifdef __cplusplus
47760 extern "C"
47761 #endif
47762 SWIGEXPORT(void) SWIG_init(void) {
47763 static PyObject *SWIG_globals = 0;
47764 static int typeinit = 0;
47765 PyObject *m, *d;
47766 int i;
47767 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47768
47769 /* Fix SwigMethods to carry the callback ptrs when needed */
47770 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47771
47772 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47773 d = PyModule_GetDict(m);
47774
47775 if (!typeinit) {
47776 #ifdef SWIG_LINK_RUNTIME
47777 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47778 #else
47779 # ifndef SWIG_STATIC_RUNTIME
47780 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47781 # endif
47782 #endif
47783 for (i = 0; swig_types_initial[i]; i++) {
47784 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47785 }
47786 typeinit = 1;
47787 }
47788 SWIG_InstallConstants(d,swig_const_table);
47789
47790
47791 #ifndef wxPyUSE_EXPORT
47792 // Make our API structure a CObject so other modules can import it
47793 // from this module.
47794 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47795 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47796 Py_XDECREF(cobj);
47797 #endif
47798
47799 {
47800 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49463 }
49464 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49465 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49466 {
49467 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49618 }
49619 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49620 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49621 {
49622 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49629 }
49630
49631 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49632
49633
49634 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49635
49636 {
49637 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49644 }
49645 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49646 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49647 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49648 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49649 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49650 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49651 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49652 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49653 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49654 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49655 {
49656 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49660 }
49661 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49662 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49663 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49664 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49665 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49666 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49667 {
49668 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49714 }
49715 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49716 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49717 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49718 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49719 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49720 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49721 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49722 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49723 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49724 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49725 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49726 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49727 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49728 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49729 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49730 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49731 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49732 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49733 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49734 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49735 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49736 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49737 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49738 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49739 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49740 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49741 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49742 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49743 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49744 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49745 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49746 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49747 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49748 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49749 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49750 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49751 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49752 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49753 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49754 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49755 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49756 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49757 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49758 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49759 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49760 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49761 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49762 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49763 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49764 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49765 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49766 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49767 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49768 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49769 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49770 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49771 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49772 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49773 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49774 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49775 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49776 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49777 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49778 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49779 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49780 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49781 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49782 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49783 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49784 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49785 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49786 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49787 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49788 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49789 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49790 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49791 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49792 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49793 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49794 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49795 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49796 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49797 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49798 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49799 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49800 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49801 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49802 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49803 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49804 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49805 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49806 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49807 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49808 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49809 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49810 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49811 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49812 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49813 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49814 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49815 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49816 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49817 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49818 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49819 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49820 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49821 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49822 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49823 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49824 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49825 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49826 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49827 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49828 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49829 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49830 {
49831 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49853 }
49854 {
49855 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49856 }
49857 {
49858 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49859 }
49860 {
49861 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49868 }
49869 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49870 {
49871 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49887 }
49888 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49889 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49890 {
49891 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49904 }
49905 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49906 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49907 {
49908 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49915 }
49916 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49917 {
49918 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49940 }
49941 {
49942 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49943 }
49944 {
49945 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49946 }
49947 {
49948 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49949 }
49950 {
49951 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49952 }
49953 {
49954 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49955 }
49956 {
49957 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49958 }
49959 {
49960 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49961 }
49962 {
49963 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49964 }
49965 {
49966 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49967 }
49968 {
49969 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49970 }
49971 {
49972 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49973 }
49974
49975 // Initialize threading, some globals and such
49976 __wxPyPreStart(d);
49977
49978
49979 // Although these are defined in __version__ they need to be here too so
49980 // that an assert can be done to ensure that the wxPython and the wxWindows
49981 // versions match.
49982 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49983 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49984 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49985
49986 }
49987
wxWidgets (Impactor)