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


0a71f6568db735938b2371d2c3105873d11c2a98
[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_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj;
26549 wxWindow *arg1 = (wxWindow *) 0 ;
26550 wxSize result;
26551 PyObject * obj0 = 0 ;
26552 char *kwnames[] = {
26553 (char *) "self", NULL
26554 };
26555
26556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26558 if (SWIG_arg_fail(1)) SWIG_fail;
26559 {
26560 PyThreadState* __tstate = wxPyBeginAllowThreads();
26561 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26562
26563 wxPyEndAllowThreads(__tstate);
26564 if (PyErr_Occurred()) SWIG_fail;
26565 }
26566 {
26567 wxSize * resultptr;
26568 resultptr = new wxSize((wxSize &)(result));
26569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26570 }
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj;
26579 wxWindow *arg1 = (wxWindow *) 0 ;
26580 wxSize result;
26581 PyObject * obj0 = 0 ;
26582 char *kwnames[] = {
26583 (char *) "self", NULL
26584 };
26585
26586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26588 if (SWIG_arg_fail(1)) SWIG_fail;
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26592
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 {
26597 wxSize * resultptr;
26598 resultptr = new wxSize((wxSize &)(result));
26599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26600 }
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj;
26609 wxWindow *arg1 = (wxWindow *) 0 ;
26610 int arg2 = (int) wxBOTH ;
26611 PyObject * obj0 = 0 ;
26612 PyObject * obj1 = 0 ;
26613 char *kwnames[] = {
26614 (char *) "self",(char *) "direction", NULL
26615 };
26616
26617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26619 if (SWIG_arg_fail(1)) SWIG_fail;
26620 if (obj1) {
26621 {
26622 arg2 = (int)(SWIG_As_int(obj1));
26623 if (SWIG_arg_fail(2)) SWIG_fail;
26624 }
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->Center(arg2);
26629
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 Py_INCREF(Py_None); resultobj = Py_None;
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj;
26642 wxWindow *arg1 = (wxWindow *) 0 ;
26643 int arg2 = (int) wxBOTH ;
26644 PyObject * obj0 = 0 ;
26645 PyObject * obj1 = 0 ;
26646 char *kwnames[] = {
26647 (char *) "self",(char *) "dir", NULL
26648 };
26649
26650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26652 if (SWIG_arg_fail(1)) SWIG_fail;
26653 if (obj1) {
26654 {
26655 arg2 = (int)(SWIG_As_int(obj1));
26656 if (SWIG_arg_fail(2)) SWIG_fail;
26657 }
26658 }
26659 {
26660 PyThreadState* __tstate = wxPyBeginAllowThreads();
26661 (arg1)->CenterOnScreen(arg2);
26662
26663 wxPyEndAllowThreads(__tstate);
26664 if (PyErr_Occurred()) SWIG_fail;
26665 }
26666 Py_INCREF(Py_None); resultobj = Py_None;
26667 return resultobj;
26668 fail:
26669 return NULL;
26670 }
26671
26672
26673 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26674 PyObject *resultobj;
26675 wxWindow *arg1 = (wxWindow *) 0 ;
26676 int arg2 = (int) wxBOTH ;
26677 PyObject * obj0 = 0 ;
26678 PyObject * obj1 = 0 ;
26679 char *kwnames[] = {
26680 (char *) "self",(char *) "dir", NULL
26681 };
26682
26683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26685 if (SWIG_arg_fail(1)) SWIG_fail;
26686 if (obj1) {
26687 {
26688 arg2 = (int)(SWIG_As_int(obj1));
26689 if (SWIG_arg_fail(2)) SWIG_fail;
26690 }
26691 }
26692 {
26693 PyThreadState* __tstate = wxPyBeginAllowThreads();
26694 (arg1)->CenterOnParent(arg2);
26695
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 Py_INCREF(Py_None); resultobj = Py_None;
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26707 PyObject *resultobj;
26708 wxWindow *arg1 = (wxWindow *) 0 ;
26709 PyObject * obj0 = 0 ;
26710 char *kwnames[] = {
26711 (char *) "self", NULL
26712 };
26713
26714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26716 if (SWIG_arg_fail(1)) SWIG_fail;
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 (arg1)->Fit();
26720
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 Py_INCREF(Py_None); resultobj = Py_None;
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj;
26733 wxWindow *arg1 = (wxWindow *) 0 ;
26734 PyObject * obj0 = 0 ;
26735 char *kwnames[] = {
26736 (char *) "self", NULL
26737 };
26738
26739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26741 if (SWIG_arg_fail(1)) SWIG_fail;
26742 {
26743 PyThreadState* __tstate = wxPyBeginAllowThreads();
26744 (arg1)->FitInside();
26745
26746 wxPyEndAllowThreads(__tstate);
26747 if (PyErr_Occurred()) SWIG_fail;
26748 }
26749 Py_INCREF(Py_None); resultobj = Py_None;
26750 return resultobj;
26751 fail:
26752 return NULL;
26753 }
26754
26755
26756 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26757 PyObject *resultobj;
26758 wxWindow *arg1 = (wxWindow *) 0 ;
26759 int arg2 ;
26760 int arg3 ;
26761 int arg4 = (int) -1 ;
26762 int arg5 = (int) -1 ;
26763 int arg6 = (int) -1 ;
26764 int arg7 = (int) -1 ;
26765 PyObject * obj0 = 0 ;
26766 PyObject * obj1 = 0 ;
26767 PyObject * obj2 = 0 ;
26768 PyObject * obj3 = 0 ;
26769 PyObject * obj4 = 0 ;
26770 PyObject * obj5 = 0 ;
26771 PyObject * obj6 = 0 ;
26772 char *kwnames[] = {
26773 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26774 };
26775
26776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26778 if (SWIG_arg_fail(1)) SWIG_fail;
26779 {
26780 arg2 = (int)(SWIG_As_int(obj1));
26781 if (SWIG_arg_fail(2)) SWIG_fail;
26782 }
26783 {
26784 arg3 = (int)(SWIG_As_int(obj2));
26785 if (SWIG_arg_fail(3)) SWIG_fail;
26786 }
26787 if (obj3) {
26788 {
26789 arg4 = (int)(SWIG_As_int(obj3));
26790 if (SWIG_arg_fail(4)) SWIG_fail;
26791 }
26792 }
26793 if (obj4) {
26794 {
26795 arg5 = (int)(SWIG_As_int(obj4));
26796 if (SWIG_arg_fail(5)) SWIG_fail;
26797 }
26798 }
26799 if (obj5) {
26800 {
26801 arg6 = (int)(SWIG_As_int(obj5));
26802 if (SWIG_arg_fail(6)) SWIG_fail;
26803 }
26804 }
26805 if (obj6) {
26806 {
26807 arg7 = (int)(SWIG_As_int(obj6));
26808 if (SWIG_arg_fail(7)) SWIG_fail;
26809 }
26810 }
26811 {
26812 PyThreadState* __tstate = wxPyBeginAllowThreads();
26813 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26814
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 Py_INCREF(Py_None); resultobj = Py_None;
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26826 PyObject *resultobj;
26827 wxWindow *arg1 = (wxWindow *) 0 ;
26828 wxSize *arg2 = 0 ;
26829 wxSize const &arg3_defvalue = wxDefaultSize ;
26830 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26831 wxSize const &arg4_defvalue = wxDefaultSize ;
26832 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26833 wxSize temp2 ;
26834 wxSize temp3 ;
26835 wxSize temp4 ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 PyObject * obj2 = 0 ;
26839 PyObject * obj3 = 0 ;
26840 char *kwnames[] = {
26841 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26842 };
26843
26844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26846 if (SWIG_arg_fail(1)) SWIG_fail;
26847 {
26848 arg2 = &temp2;
26849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26850 }
26851 if (obj2) {
26852 {
26853 arg3 = &temp3;
26854 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26855 }
26856 }
26857 if (obj3) {
26858 {
26859 arg4 = &temp4;
26860 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26861 }
26862 }
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26866
26867 wxPyEndAllowThreads(__tstate);
26868 if (PyErr_Occurred()) SWIG_fail;
26869 }
26870 Py_INCREF(Py_None); resultobj = Py_None;
26871 return resultobj;
26872 fail:
26873 return NULL;
26874 }
26875
26876
26877 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj;
26879 wxWindow *arg1 = (wxWindow *) 0 ;
26880 int arg2 ;
26881 int arg3 ;
26882 int arg4 = (int) -1 ;
26883 int arg5 = (int) -1 ;
26884 PyObject * obj0 = 0 ;
26885 PyObject * obj1 = 0 ;
26886 PyObject * obj2 = 0 ;
26887 PyObject * obj3 = 0 ;
26888 PyObject * obj4 = 0 ;
26889 char *kwnames[] = {
26890 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26891 };
26892
26893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26895 if (SWIG_arg_fail(1)) SWIG_fail;
26896 {
26897 arg2 = (int)(SWIG_As_int(obj1));
26898 if (SWIG_arg_fail(2)) SWIG_fail;
26899 }
26900 {
26901 arg3 = (int)(SWIG_As_int(obj2));
26902 if (SWIG_arg_fail(3)) SWIG_fail;
26903 }
26904 if (obj3) {
26905 {
26906 arg4 = (int)(SWIG_As_int(obj3));
26907 if (SWIG_arg_fail(4)) SWIG_fail;
26908 }
26909 }
26910 if (obj4) {
26911 {
26912 arg5 = (int)(SWIG_As_int(obj4));
26913 if (SWIG_arg_fail(5)) SWIG_fail;
26914 }
26915 }
26916 {
26917 PyThreadState* __tstate = wxPyBeginAllowThreads();
26918 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26919
26920 wxPyEndAllowThreads(__tstate);
26921 if (PyErr_Occurred()) SWIG_fail;
26922 }
26923 Py_INCREF(Py_None); resultobj = Py_None;
26924 return resultobj;
26925 fail:
26926 return NULL;
26927 }
26928
26929
26930 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26931 PyObject *resultobj;
26932 wxWindow *arg1 = (wxWindow *) 0 ;
26933 wxSize *arg2 = 0 ;
26934 wxSize const &arg3_defvalue = wxDefaultSize ;
26935 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26936 wxSize temp2 ;
26937 wxSize temp3 ;
26938 PyObject * obj0 = 0 ;
26939 PyObject * obj1 = 0 ;
26940 PyObject * obj2 = 0 ;
26941 char *kwnames[] = {
26942 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26943 };
26944
26945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26947 if (SWIG_arg_fail(1)) SWIG_fail;
26948 {
26949 arg2 = &temp2;
26950 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26951 }
26952 if (obj2) {
26953 {
26954 arg3 = &temp3;
26955 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26956 }
26957 }
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26961
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 Py_INCREF(Py_None); resultobj = Py_None;
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26973 PyObject *resultobj;
26974 wxWindow *arg1 = (wxWindow *) 0 ;
26975 wxSize result;
26976 PyObject * obj0 = 0 ;
26977 char *kwnames[] = {
26978 (char *) "self", NULL
26979 };
26980
26981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26983 if (SWIG_arg_fail(1)) SWIG_fail;
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 result = ((wxWindow const *)arg1)->GetMaxSize();
26987
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 {
26992 wxSize * resultptr;
26993 resultptr = new wxSize((wxSize &)(result));
26994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26995 }
26996 return resultobj;
26997 fail:
26998 return NULL;
26999 }
27000
27001
27002 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27003 PyObject *resultobj;
27004 wxWindow *arg1 = (wxWindow *) 0 ;
27005 wxSize result;
27006 PyObject * obj0 = 0 ;
27007 char *kwnames[] = {
27008 (char *) "self", NULL
27009 };
27010
27011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27013 if (SWIG_arg_fail(1)) SWIG_fail;
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 result = ((wxWindow const *)arg1)->GetMinSize();
27017
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 {
27022 wxSize * resultptr;
27023 resultptr = new wxSize((wxSize &)(result));
27024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27025 }
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj;
27034 wxWindow *arg1 = (wxWindow *) 0 ;
27035 wxSize *arg2 = 0 ;
27036 wxSize temp2 ;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self",(char *) "minSize", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
27048 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27049 }
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 (arg1)->SetMinSize((wxSize const &)*arg2);
27053
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 Py_INCREF(Py_None); resultobj = Py_None;
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_Window_SetMaxSize(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 *) "maxSize", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",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)->SetMaxSize((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_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 int result;
27100 PyObject * obj0 = 0 ;
27101 char *kwnames[] = {
27102 (char *) "self", NULL
27103 };
27104
27105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27111
27112 wxPyEndAllowThreads(__tstate);
27113 if (PyErr_Occurred()) SWIG_fail;
27114 }
27115 {
27116 resultobj = SWIG_From_int((int)(result));
27117 }
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxWindow *arg1 = (wxWindow *) 0 ;
27127 int result;
27128 PyObject * obj0 = 0 ;
27129 char *kwnames[] = {
27130 (char *) "self", NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27135 if (SWIG_arg_fail(1)) SWIG_fail;
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = SWIG_From_int((int)(result));
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj;
27154 wxWindow *arg1 = (wxWindow *) 0 ;
27155 int result;
27156 PyObject * obj0 = 0 ;
27157 char *kwnames[] = {
27158 (char *) "self", NULL
27159 };
27160
27161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(1)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = SWIG_From_int((int)(result));
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxWindow *arg1 = (wxWindow *) 0 ;
27183 int result;
27184 PyObject * obj0 = 0 ;
27185 char *kwnames[] = {
27186 (char *) "self", NULL
27187 };
27188
27189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27191 if (SWIG_arg_fail(1)) SWIG_fail;
27192 {
27193 PyThreadState* __tstate = wxPyBeginAllowThreads();
27194 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27195
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = SWIG_From_int((int)(result));
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27209 PyObject *resultobj;
27210 wxWindow *arg1 = (wxWindow *) 0 ;
27211 wxSize *arg2 = 0 ;
27212 wxSize temp2 ;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 char *kwnames[] = {
27216 (char *) "self",(char *) "size", NULL
27217 };
27218
27219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 {
27223 arg2 = &temp2;
27224 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27225 }
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27229
27230 wxPyEndAllowThreads(__tstate);
27231 if (PyErr_Occurred()) SWIG_fail;
27232 }
27233 Py_INCREF(Py_None); resultobj = Py_None;
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj;
27242 wxWindow *arg1 = (wxWindow *) 0 ;
27243 int arg2 ;
27244 int arg3 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 PyObject * obj2 = 0 ;
27248 char *kwnames[] = {
27249 (char *) "self",(char *) "w",(char *) "h", NULL
27250 };
27251
27252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27254 if (SWIG_arg_fail(1)) SWIG_fail;
27255 {
27256 arg2 = (int)(SWIG_As_int(obj1));
27257 if (SWIG_arg_fail(2)) SWIG_fail;
27258 }
27259 {
27260 arg3 = (int)(SWIG_As_int(obj2));
27261 if (SWIG_arg_fail(3)) SWIG_fail;
27262 }
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 (arg1)->SetVirtualSize(arg2,arg3);
27266
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 Py_INCREF(Py_None); resultobj = Py_None;
27271 return resultobj;
27272 fail:
27273 return NULL;
27274 }
27275
27276
27277 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27278 PyObject *resultobj;
27279 wxWindow *arg1 = (wxWindow *) 0 ;
27280 wxSize result;
27281 PyObject * obj0 = 0 ;
27282 char *kwnames[] = {
27283 (char *) "self", NULL
27284 };
27285
27286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27288 if (SWIG_arg_fail(1)) SWIG_fail;
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = ((wxWindow const *)arg1)->GetVirtualSize();
27292
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 wxSize * resultptr;
27298 resultptr = new wxSize((wxSize &)(result));
27299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27300 }
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27308 PyObject *resultobj;
27309 wxWindow *arg1 = (wxWindow *) 0 ;
27310 int *arg2 = (int *) 0 ;
27311 int *arg3 = (int *) 0 ;
27312 int temp2 ;
27313 int res2 = 0 ;
27314 int temp3 ;
27315 int res3 = 0 ;
27316 PyObject * obj0 = 0 ;
27317 char *kwnames[] = {
27318 (char *) "self", NULL
27319 };
27320
27321 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27322 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27325 if (SWIG_arg_fail(1)) SWIG_fail;
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27329
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 Py_INCREF(Py_None); resultobj = Py_None;
27334 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27335 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27336 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27337 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27338 return resultobj;
27339 fail:
27340 return NULL;
27341 }
27342
27343
27344 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27345 PyObject *resultobj;
27346 wxWindow *arg1 = (wxWindow *) 0 ;
27347 wxSize result;
27348 PyObject * obj0 = 0 ;
27349 char *kwnames[] = {
27350 (char *) "self", NULL
27351 };
27352
27353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27355 if (SWIG_arg_fail(1)) SWIG_fail;
27356 {
27357 PyThreadState* __tstate = wxPyBeginAllowThreads();
27358 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27359
27360 wxPyEndAllowThreads(__tstate);
27361 if (PyErr_Occurred()) SWIG_fail;
27362 }
27363 {
27364 wxSize * resultptr;
27365 resultptr = new wxSize((wxSize &)(result));
27366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27367 }
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj;
27376 wxWindow *arg1 = (wxWindow *) 0 ;
27377 bool arg2 = (bool) true ;
27378 bool result;
27379 PyObject * obj0 = 0 ;
27380 PyObject * obj1 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self",(char *) "show", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 if (obj1) {
27389 {
27390 arg2 = (bool)(SWIG_As_bool(obj1));
27391 if (SWIG_arg_fail(2)) SWIG_fail;
27392 }
27393 }
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 result = (bool)(arg1)->Show(arg2);
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 {
27402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27403 }
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj;
27412 wxWindow *arg1 = (wxWindow *) 0 ;
27413 bool result;
27414 PyObject * obj0 = 0 ;
27415 char *kwnames[] = {
27416 (char *) "self", NULL
27417 };
27418
27419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27421 if (SWIG_arg_fail(1)) SWIG_fail;
27422 {
27423 PyThreadState* __tstate = wxPyBeginAllowThreads();
27424 result = (bool)(arg1)->Hide();
27425
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 {
27430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27431 }
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27439 PyObject *resultobj;
27440 wxWindow *arg1 = (wxWindow *) 0 ;
27441 bool arg2 = (bool) true ;
27442 bool result;
27443 PyObject * obj0 = 0 ;
27444 PyObject * obj1 = 0 ;
27445 char *kwnames[] = {
27446 (char *) "self",(char *) "enable", NULL
27447 };
27448
27449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27451 if (SWIG_arg_fail(1)) SWIG_fail;
27452 if (obj1) {
27453 {
27454 arg2 = (bool)(SWIG_As_bool(obj1));
27455 if (SWIG_arg_fail(2)) SWIG_fail;
27456 }
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (bool)(arg1)->Enable(arg2);
27461
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj;
27476 wxWindow *arg1 = (wxWindow *) 0 ;
27477 bool result;
27478 PyObject * obj0 = 0 ;
27479 char *kwnames[] = {
27480 (char *) "self", NULL
27481 };
27482
27483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27485 if (SWIG_arg_fail(1)) SWIG_fail;
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)(arg1)->Disable();
27489
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 {
27494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27495 }
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27503 PyObject *resultobj;
27504 wxWindow *arg1 = (wxWindow *) 0 ;
27505 bool result;
27506 PyObject * obj0 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = (bool)((wxWindow const *)arg1)->IsShown();
27517
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 {
27522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27523 }
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj;
27532 wxWindow *arg1 = (wxWindow *) 0 ;
27533 bool result;
27534 PyObject * obj0 = 0 ;
27535 char *kwnames[] = {
27536 (char *) "self", NULL
27537 };
27538
27539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27541 if (SWIG_arg_fail(1)) SWIG_fail;
27542 {
27543 PyThreadState* __tstate = wxPyBeginAllowThreads();
27544 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27545
27546 wxPyEndAllowThreads(__tstate);
27547 if (PyErr_Occurred()) SWIG_fail;
27548 }
27549 {
27550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27551 }
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27559 PyObject *resultobj;
27560 wxWindow *arg1 = (wxWindow *) 0 ;
27561 long arg2 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char *kwnames[] = {
27565 (char *) "self",(char *) "style", NULL
27566 };
27567
27568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27570 if (SWIG_arg_fail(1)) SWIG_fail;
27571 {
27572 arg2 = (long)(SWIG_As_long(obj1));
27573 if (SWIG_arg_fail(2)) SWIG_fail;
27574 }
27575 {
27576 PyThreadState* __tstate = wxPyBeginAllowThreads();
27577 (arg1)->SetWindowStyleFlag(arg2);
27578
27579 wxPyEndAllowThreads(__tstate);
27580 if (PyErr_Occurred()) SWIG_fail;
27581 }
27582 Py_INCREF(Py_None); resultobj = Py_None;
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj;
27591 wxWindow *arg1 = (wxWindow *) 0 ;
27592 long result;
27593 PyObject * obj0 = 0 ;
27594 char *kwnames[] = {
27595 (char *) "self", NULL
27596 };
27597
27598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27600 if (SWIG_arg_fail(1)) SWIG_fail;
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27604
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 {
27609 resultobj = SWIG_From_long((long)(result));
27610 }
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27618 PyObject *resultobj;
27619 wxWindow *arg1 = (wxWindow *) 0 ;
27620 int arg2 ;
27621 bool result;
27622 PyObject * obj0 = 0 ;
27623 PyObject * obj1 = 0 ;
27624 char *kwnames[] = {
27625 (char *) "self",(char *) "flag", NULL
27626 };
27627
27628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(1)) SWIG_fail;
27631 {
27632 arg2 = (int)(SWIG_As_int(obj1));
27633 if (SWIG_arg_fail(2)) SWIG_fail;
27634 }
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxWindow *arg1 = (wxWindow *) 0 ;
27654 bool result;
27655 PyObject * obj0 = 0 ;
27656 char *kwnames[] = {
27657 (char *) "self", NULL
27658 };
27659
27660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 result = (bool)((wxWindow const *)arg1)->IsRetained();
27666
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 {
27671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27672 }
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj;
27681 wxWindow *arg1 = (wxWindow *) 0 ;
27682 long arg2 ;
27683 PyObject * obj0 = 0 ;
27684 PyObject * obj1 = 0 ;
27685 char *kwnames[] = {
27686 (char *) "self",(char *) "exStyle", NULL
27687 };
27688
27689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27691 if (SWIG_arg_fail(1)) SWIG_fail;
27692 {
27693 arg2 = (long)(SWIG_As_long(obj1));
27694 if (SWIG_arg_fail(2)) SWIG_fail;
27695 }
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 (arg1)->SetExtraStyle(arg2);
27699
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 Py_INCREF(Py_None); resultobj = Py_None;
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27711 PyObject *resultobj;
27712 wxWindow *arg1 = (wxWindow *) 0 ;
27713 long result;
27714 PyObject * obj0 = 0 ;
27715 char *kwnames[] = {
27716 (char *) "self", NULL
27717 };
27718
27719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27721 if (SWIG_arg_fail(1)) SWIG_fail;
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27725
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = SWIG_From_long((long)(result));
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27739 PyObject *resultobj;
27740 wxWindow *arg1 = (wxWindow *) 0 ;
27741 bool arg2 = (bool) true ;
27742 PyObject * obj0 = 0 ;
27743 PyObject * obj1 = 0 ;
27744 char *kwnames[] = {
27745 (char *) "self",(char *) "modal", NULL
27746 };
27747
27748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27750 if (SWIG_arg_fail(1)) SWIG_fail;
27751 if (obj1) {
27752 {
27753 arg2 = (bool)(SWIG_As_bool(obj1));
27754 if (SWIG_arg_fail(2)) SWIG_fail;
27755 }
27756 }
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 (arg1)->MakeModal(arg2);
27760
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 Py_INCREF(Py_None); resultobj = Py_None;
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj;
27773 wxWindow *arg1 = (wxWindow *) 0 ;
27774 bool arg2 ;
27775 PyObject * obj0 = 0 ;
27776 PyObject * obj1 = 0 ;
27777 char *kwnames[] = {
27778 (char *) "self",(char *) "enableTheme", NULL
27779 };
27780
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 {
27785 arg2 = (bool)(SWIG_As_bool(obj1));
27786 if (SWIG_arg_fail(2)) SWIG_fail;
27787 }
27788 {
27789 PyThreadState* __tstate = wxPyBeginAllowThreads();
27790 (arg1)->SetThemeEnabled(arg2);
27791
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 Py_INCREF(Py_None); resultobj = Py_None;
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27803 PyObject *resultobj;
27804 wxWindow *arg1 = (wxWindow *) 0 ;
27805 bool result;
27806 PyObject * obj0 = 0 ;
27807 char *kwnames[] = {
27808 (char *) "self", NULL
27809 };
27810
27811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27813 if (SWIG_arg_fail(1)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 {
27822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27823 }
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj;
27832 wxWindow *arg1 = (wxWindow *) 0 ;
27833 PyObject * obj0 = 0 ;
27834 char *kwnames[] = {
27835 (char *) "self", NULL
27836 };
27837
27838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27840 if (SWIG_arg_fail(1)) SWIG_fail;
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 (arg1)->SetFocus();
27844
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 Py_INCREF(Py_None); resultobj = Py_None;
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj;
27857 wxWindow *arg1 = (wxWindow *) 0 ;
27858 PyObject * obj0 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "self", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(1)) SWIG_fail;
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 (arg1)->SetFocusFromKbd();
27869
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 Py_INCREF(Py_None); resultobj = Py_None;
27874 return resultobj;
27875 fail:
27876 return NULL;
27877 }
27878
27879
27880 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27881 PyObject *resultobj;
27882 wxWindow *result;
27883 char *kwnames[] = {
27884 NULL
27885 };
27886
27887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27888 {
27889 if (!wxPyCheckForApp()) SWIG_fail;
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (wxWindow *)wxWindow::FindFocus();
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = wxPyMake_wxObject(result, 0);
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 bool result;
27909 PyObject * obj0 = 0 ;
27910 char *kwnames[] = {
27911 (char *) "self", NULL
27912 };
27913
27914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27920
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27926 }
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 bool result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 wxWindow *result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = wxPyMake_wxObject(result, 0);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxWindow *arg1 = (wxWindow *) 0 ;
27992 wxWindow *arg2 = (wxWindow *) 0 ;
27993 wxWindow *result;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char *kwnames[] = {
27997 (char *) "self",(char *) "child", NULL
27998 };
27999
28000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28002 if (SWIG_arg_fail(1)) SWIG_fail;
28003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28004 if (SWIG_arg_fail(2)) SWIG_fail;
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
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_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj;
28023 wxWindow *arg1 = (wxWindow *) 0 ;
28024 wxWindow *arg2 = (wxWindow *) 0 ;
28025 PyObject * obj0 = 0 ;
28026 PyObject * obj1 = 0 ;
28027 char *kwnames[] = {
28028 (char *) "self",(char *) "win", NULL
28029 };
28030
28031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28033 if (SWIG_arg_fail(1)) SWIG_fail;
28034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28035 if (SWIG_arg_fail(2)) SWIG_fail;
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 (arg1)->SetTmpDefaultItem(arg2);
28039
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 Py_INCREF(Py_None); resultobj = Py_None;
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj;
28052 wxWindow *arg1 = (wxWindow *) 0 ;
28053 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28054 bool result;
28055 PyObject * obj0 = 0 ;
28056 PyObject * obj1 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "self",(char *) "flags", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(1)) SWIG_fail;
28064 if (obj1) {
28065 {
28066 arg2 = (int)(SWIG_As_int(obj1));
28067 if (SWIG_arg_fail(2)) SWIG_fail;
28068 }
28069 }
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 result = (bool)(arg1)->Navigate(arg2);
28073
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 {
28078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28079 }
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj;
28088 wxWindow *arg1 = (wxWindow *) 0 ;
28089 wxWindow *arg2 = (wxWindow *) 0 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char *kwnames[] = {
28093 (char *) "self",(char *) "win", NULL
28094 };
28095
28096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28098 if (SWIG_arg_fail(1)) SWIG_fail;
28099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28100 if (SWIG_arg_fail(2)) SWIG_fail;
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 (arg1)->MoveAfterInTabOrder(arg2);
28104
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 Py_INCREF(Py_None); resultobj = Py_None;
28109 return resultobj;
28110 fail:
28111 return NULL;
28112 }
28113
28114
28115 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28116 PyObject *resultobj;
28117 wxWindow *arg1 = (wxWindow *) 0 ;
28118 wxWindow *arg2 = (wxWindow *) 0 ;
28119 PyObject * obj0 = 0 ;
28120 PyObject * obj1 = 0 ;
28121 char *kwnames[] = {
28122 (char *) "self",(char *) "win", NULL
28123 };
28124
28125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28127 if (SWIG_arg_fail(1)) SWIG_fail;
28128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28129 if (SWIG_arg_fail(2)) SWIG_fail;
28130 {
28131 PyThreadState* __tstate = wxPyBeginAllowThreads();
28132 (arg1)->MoveBeforeInTabOrder(arg2);
28133
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 Py_INCREF(Py_None); resultobj = Py_None;
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj;
28146 wxWindow *arg1 = (wxWindow *) 0 ;
28147 PyObject *result;
28148 PyObject * obj0 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "self", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 result = (PyObject *)wxWindow_GetChildren(arg1);
28159
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = result;
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28171 PyObject *resultobj;
28172 wxWindow *arg1 = (wxWindow *) 0 ;
28173 wxWindow *result;
28174 PyObject * obj0 = 0 ;
28175 char *kwnames[] = {
28176 (char *) "self", NULL
28177 };
28178
28179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28181 if (SWIG_arg_fail(1)) SWIG_fail;
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28185
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 {
28190 resultobj = wxPyMake_wxObject(result, 0);
28191 }
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj;
28200 wxWindow *arg1 = (wxWindow *) 0 ;
28201 wxWindow *result;
28202 PyObject * obj0 = 0 ;
28203 char *kwnames[] = {
28204 (char *) "self", NULL
28205 };
28206
28207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28209 if (SWIG_arg_fail(1)) SWIG_fail;
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28213
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 {
28218 resultobj = wxPyMake_wxObject(result, 0);
28219 }
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj;
28228 wxWindow *arg1 = (wxWindow *) 0 ;
28229 bool result;
28230 PyObject * obj0 = 0 ;
28231 char *kwnames[] = {
28232 (char *) "self", NULL
28233 };
28234
28235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28237 if (SWIG_arg_fail(1)) SWIG_fail;
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28241
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 wxWindow *arg2 = (wxWindow *) 0 ;
28258 bool result;
28259 PyObject * obj0 = 0 ;
28260 PyObject * obj1 = 0 ;
28261 char *kwnames[] = {
28262 (char *) "self",(char *) "newParent", NULL
28263 };
28264
28265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28267 if (SWIG_arg_fail(1)) SWIG_fail;
28268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28269 if (SWIG_arg_fail(2)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = (bool)(arg1)->Reparent(arg2);
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_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj;
28288 wxWindow *arg1 = (wxWindow *) 0 ;
28289 wxWindow *arg2 = (wxWindow *) 0 ;
28290 PyObject * obj0 = 0 ;
28291 PyObject * obj1 = 0 ;
28292 char *kwnames[] = {
28293 (char *) "self",(char *) "child", NULL
28294 };
28295
28296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28298 if (SWIG_arg_fail(1)) SWIG_fail;
28299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28300 if (SWIG_arg_fail(2)) SWIG_fail;
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 (arg1)->AddChild(arg2);
28304
28305 wxPyEndAllowThreads(__tstate);
28306 if (PyErr_Occurred()) SWIG_fail;
28307 }
28308 Py_INCREF(Py_None); resultobj = Py_None;
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28316 PyObject *resultobj;
28317 wxWindow *arg1 = (wxWindow *) 0 ;
28318 wxWindow *arg2 = (wxWindow *) 0 ;
28319 PyObject * obj0 = 0 ;
28320 PyObject * obj1 = 0 ;
28321 char *kwnames[] = {
28322 (char *) "self",(char *) "child", NULL
28323 };
28324
28325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28327 if (SWIG_arg_fail(1)) SWIG_fail;
28328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28329 if (SWIG_arg_fail(2)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 (arg1)->RemoveChild(arg2);
28333
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 Py_INCREF(Py_None); resultobj = Py_None;
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj;
28346 wxWindow *arg1 = (wxWindow *) 0 ;
28347 long arg2 ;
28348 wxWindow *result;
28349 PyObject * obj0 = 0 ;
28350 PyObject * obj1 = 0 ;
28351 char *kwnames[] = {
28352 (char *) "self",(char *) "winid", NULL
28353 };
28354
28355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28357 if (SWIG_arg_fail(1)) SWIG_fail;
28358 {
28359 arg2 = (long)(SWIG_As_long(obj1));
28360 if (SWIG_arg_fail(2)) SWIG_fail;
28361 }
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (wxWindow *)(arg1)->FindWindow(arg2);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 {
28370 resultobj = wxPyMake_wxObject(result, 0);
28371 }
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxWindow *arg1 = (wxWindow *) 0 ;
28381 wxString *arg2 = 0 ;
28382 wxWindow *result;
28383 bool temp2 = false ;
28384 PyObject * obj0 = 0 ;
28385 PyObject * obj1 = 0 ;
28386 char *kwnames[] = {
28387 (char *) "self",(char *) "name", NULL
28388 };
28389
28390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28392 if (SWIG_arg_fail(1)) SWIG_fail;
28393 {
28394 arg2 = wxString_in_helper(obj1);
28395 if (arg2 == NULL) SWIG_fail;
28396 temp2 = true;
28397 }
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28401
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 {
28406 resultobj = wxPyMake_wxObject(result, 0);
28407 }
28408 {
28409 if (temp2)
28410 delete arg2;
28411 }
28412 return resultobj;
28413 fail:
28414 {
28415 if (temp2)
28416 delete arg2;
28417 }
28418 return NULL;
28419 }
28420
28421
28422 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj;
28424 wxWindow *arg1 = (wxWindow *) 0 ;
28425 wxEvtHandler *result;
28426 PyObject * obj0 = 0 ;
28427 char *kwnames[] = {
28428 (char *) "self", NULL
28429 };
28430
28431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28433 if (SWIG_arg_fail(1)) SWIG_fail;
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28437
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 {
28442 resultobj = wxPyMake_wxObject(result, 0);
28443 }
28444 return resultobj;
28445 fail:
28446 return NULL;
28447 }
28448
28449
28450 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28451 PyObject *resultobj;
28452 wxWindow *arg1 = (wxWindow *) 0 ;
28453 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 char *kwnames[] = {
28457 (char *) "self",(char *) "handler", NULL
28458 };
28459
28460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28462 if (SWIG_arg_fail(1)) SWIG_fail;
28463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28464 if (SWIG_arg_fail(2)) SWIG_fail;
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 (arg1)->SetEventHandler(arg2);
28468
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 Py_INCREF(Py_None); resultobj = Py_None;
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28480 PyObject *resultobj;
28481 wxWindow *arg1 = (wxWindow *) 0 ;
28482 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char *kwnames[] = {
28486 (char *) "self",(char *) "handler", NULL
28487 };
28488
28489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(1)) SWIG_fail;
28492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28493 if (SWIG_arg_fail(2)) SWIG_fail;
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 (arg1)->PushEventHandler(arg2);
28497
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 Py_INCREF(Py_None); resultobj = Py_None;
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj;
28510 wxWindow *arg1 = (wxWindow *) 0 ;
28511 bool arg2 = (bool) false ;
28512 wxEvtHandler *result;
28513 PyObject * obj0 = 0 ;
28514 PyObject * obj1 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "self",(char *) "deleteHandler", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 if (obj1) {
28523 {
28524 arg2 = (bool)(SWIG_As_bool(obj1));
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 }
28527 }
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 resultobj = wxPyMake_wxObject(result, 0);
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj;
28546 wxWindow *arg1 = (wxWindow *) 0 ;
28547 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28548 bool result;
28549 PyObject * obj0 = 0 ;
28550 PyObject * obj1 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self",(char *) "handler", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28559 if (SWIG_arg_fail(2)) SWIG_fail;
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (bool)(arg1)->RemoveEventHandler(arg2);
28563
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 {
28568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxWindow *arg1 = (wxWindow *) 0 ;
28579 wxValidator *arg2 = 0 ;
28580 PyObject * obj0 = 0 ;
28581 PyObject * obj1 = 0 ;
28582 char *kwnames[] = {
28583 (char *) "self",(char *) "validator", NULL
28584 };
28585
28586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28588 if (SWIG_arg_fail(1)) SWIG_fail;
28589 {
28590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(2)) SWIG_fail;
28592 if (arg2 == NULL) {
28593 SWIG_null_ref("wxValidator");
28594 }
28595 if (SWIG_arg_fail(2)) SWIG_fail;
28596 }
28597 {
28598 PyThreadState* __tstate = wxPyBeginAllowThreads();
28599 (arg1)->SetValidator((wxValidator const &)*arg2);
28600
28601 wxPyEndAllowThreads(__tstate);
28602 if (PyErr_Occurred()) SWIG_fail;
28603 }
28604 Py_INCREF(Py_None); resultobj = Py_None;
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28612 PyObject *resultobj;
28613 wxWindow *arg1 = (wxWindow *) 0 ;
28614 wxValidator *result;
28615 PyObject * obj0 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(1)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (wxValidator *)(arg1)->GetValidator();
28626
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 {
28631 resultobj = wxPyMake_wxObject(result, 0);
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 bool result;
28643 PyObject * obj0 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "self", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = (bool)(arg1)->Validate();
28654
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 {
28659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28660 }
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28668 PyObject *resultobj;
28669 wxWindow *arg1 = (wxWindow *) 0 ;
28670 bool result;
28671 PyObject * obj0 = 0 ;
28672 char *kwnames[] = {
28673 (char *) "self", NULL
28674 };
28675
28676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28678 if (SWIG_arg_fail(1)) SWIG_fail;
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (bool)(arg1)->TransferDataToWindow();
28682
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 {
28687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28688 }
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28696 PyObject *resultobj;
28697 wxWindow *arg1 = (wxWindow *) 0 ;
28698 bool result;
28699 PyObject * obj0 = 0 ;
28700 char *kwnames[] = {
28701 (char *) "self", NULL
28702 };
28703
28704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28706 if (SWIG_arg_fail(1)) SWIG_fail;
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = (bool)(arg1)->TransferDataFromWindow();
28710
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 {
28715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28716 }
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj;
28725 wxWindow *arg1 = (wxWindow *) 0 ;
28726 PyObject * obj0 = 0 ;
28727 char *kwnames[] = {
28728 (char *) "self", NULL
28729 };
28730
28731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28733 if (SWIG_arg_fail(1)) SWIG_fail;
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 (arg1)->InitDialog();
28737
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 Py_INCREF(Py_None); resultobj = Py_None;
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj;
28750 wxWindow *arg1 = (wxWindow *) 0 ;
28751 wxAcceleratorTable *arg2 = 0 ;
28752 PyObject * obj0 = 0 ;
28753 PyObject * obj1 = 0 ;
28754 char *kwnames[] = {
28755 (char *) "self",(char *) "accel", NULL
28756 };
28757
28758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 {
28762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28763 if (SWIG_arg_fail(2)) SWIG_fail;
28764 if (arg2 == NULL) {
28765 SWIG_null_ref("wxAcceleratorTable");
28766 }
28767 if (SWIG_arg_fail(2)) SWIG_fail;
28768 }
28769 {
28770 PyThreadState* __tstate = wxPyBeginAllowThreads();
28771 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28772
28773 wxPyEndAllowThreads(__tstate);
28774 if (PyErr_Occurred()) SWIG_fail;
28775 }
28776 Py_INCREF(Py_None); resultobj = Py_None;
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj;
28785 wxWindow *arg1 = (wxWindow *) 0 ;
28786 wxAcceleratorTable *result;
28787 PyObject * obj0 = 0 ;
28788 char *kwnames[] = {
28789 (char *) "self", NULL
28790 };
28791
28792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28794 if (SWIG_arg_fail(1)) SWIG_fail;
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28798
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj;
28811 wxWindow *arg1 = (wxWindow *) 0 ;
28812 int arg2 ;
28813 int arg3 ;
28814 int arg4 ;
28815 bool result;
28816 PyObject * obj0 = 0 ;
28817 PyObject * obj1 = 0 ;
28818 PyObject * obj2 = 0 ;
28819 PyObject * obj3 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
28829 if (SWIG_arg_fail(2)) SWIG_fail;
28830 }
28831 {
28832 arg3 = (int)(SWIG_As_int(obj2));
28833 if (SWIG_arg_fail(3)) SWIG_fail;
28834 }
28835 {
28836 arg4 = (int)(SWIG_As_int(obj3));
28837 if (SWIG_arg_fail(4)) SWIG_fail;
28838 }
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28842
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 {
28847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28848 }
28849 return resultobj;
28850 fail:
28851 return NULL;
28852 }
28853
28854
28855 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28856 PyObject *resultobj;
28857 wxWindow *arg1 = (wxWindow *) 0 ;
28858 int arg2 ;
28859 bool result;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char *kwnames[] = {
28863 (char *) "self",(char *) "hotkeyId", NULL
28864 };
28865
28866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(1)) SWIG_fail;
28869 {
28870 arg2 = (int)(SWIG_As_int(obj1));
28871 if (SWIG_arg_fail(2)) SWIG_fail;
28872 }
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxWindow *arg1 = (wxWindow *) 0 ;
28892 wxPoint *arg2 = 0 ;
28893 wxPoint result;
28894 wxPoint temp2 ;
28895 PyObject * obj0 = 0 ;
28896 PyObject * obj1 = 0 ;
28897 char *kwnames[] = {
28898 (char *) "self",(char *) "pt", NULL
28899 };
28900
28901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28903 if (SWIG_arg_fail(1)) SWIG_fail;
28904 {
28905 arg2 = &temp2;
28906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28907 }
28908 {
28909 PyThreadState* __tstate = wxPyBeginAllowThreads();
28910 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28911
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 wxPoint * resultptr;
28917 resultptr = new wxPoint((wxPoint &)(result));
28918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28919 }
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj;
28928 wxWindow *arg1 = (wxWindow *) 0 ;
28929 wxSize *arg2 = 0 ;
28930 wxSize result;
28931 wxSize temp2 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self",(char *) "sz", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 arg2 = &temp2;
28943 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28944 }
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28948
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 {
28953 wxSize * resultptr;
28954 resultptr = new wxSize((wxSize &)(result));
28955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28956 }
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj;
28965 wxWindow *arg1 = (wxWindow *) 0 ;
28966 wxPoint *arg2 = 0 ;
28967 wxPoint result;
28968 wxPoint temp2 ;
28969 PyObject * obj0 = 0 ;
28970 PyObject * obj1 = 0 ;
28971 char *kwnames[] = {
28972 (char *) "self",(char *) "pt", NULL
28973 };
28974
28975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28977 if (SWIG_arg_fail(1)) SWIG_fail;
28978 {
28979 arg2 = &temp2;
28980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28981 }
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28985
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 {
28990 wxPoint * resultptr;
28991 resultptr = new wxPoint((wxPoint &)(result));
28992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28993 }
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxWindow *arg1 = (wxWindow *) 0 ;
29003 wxSize *arg2 = 0 ;
29004 wxSize result;
29005 wxSize temp2 ;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 char *kwnames[] = {
29009 (char *) "self",(char *) "sz", NULL
29010 };
29011
29012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29014 if (SWIG_arg_fail(1)) SWIG_fail;
29015 {
29016 arg2 = &temp2;
29017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29018 }
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 {
29027 wxSize * resultptr;
29028 resultptr = new wxSize((wxSize &)(result));
29029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29030 }
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj;
29039 wxWindow *arg1 = (wxWindow *) 0 ;
29040 wxPoint *arg2 = 0 ;
29041 wxPoint result;
29042 wxPoint temp2 ;
29043 PyObject * obj0 = 0 ;
29044 PyObject * obj1 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "pt", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 arg2 = &temp2;
29054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29055 }
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29059
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 {
29064 wxPoint * resultptr;
29065 resultptr = new wxPoint((wxPoint &)(result));
29066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29067 }
29068 return resultobj;
29069 fail:
29070 return NULL;
29071 }
29072
29073
29074 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29075 PyObject *resultobj;
29076 wxWindow *arg1 = (wxWindow *) 0 ;
29077 wxSize *arg2 = 0 ;
29078 wxSize result;
29079 wxSize temp2 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 char *kwnames[] = {
29083 (char *) "self",(char *) "sz", NULL
29084 };
29085
29086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29088 if (SWIG_arg_fail(1)) SWIG_fail;
29089 {
29090 arg2 = &temp2;
29091 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29092 }
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29096
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 {
29101 wxSize * resultptr;
29102 resultptr = new wxSize((wxSize &)(result));
29103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29104 }
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj;
29113 wxWindow *arg1 = (wxWindow *) 0 ;
29114 int arg2 ;
29115 int arg3 ;
29116 PyObject * obj0 = 0 ;
29117 PyObject * obj1 = 0 ;
29118 PyObject * obj2 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self",(char *) "x",(char *) "y", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 arg2 = (int)(SWIG_As_int(obj1));
29128 if (SWIG_arg_fail(2)) SWIG_fail;
29129 }
29130 {
29131 arg3 = (int)(SWIG_As_int(obj2));
29132 if (SWIG_arg_fail(3)) SWIG_fail;
29133 }
29134 {
29135 PyThreadState* __tstate = wxPyBeginAllowThreads();
29136 (arg1)->WarpPointer(arg2,arg3);
29137
29138 wxPyEndAllowThreads(__tstate);
29139 if (PyErr_Occurred()) SWIG_fail;
29140 }
29141 Py_INCREF(Py_None); resultobj = Py_None;
29142 return resultobj;
29143 fail:
29144 return NULL;
29145 }
29146
29147
29148 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29149 PyObject *resultobj;
29150 wxWindow *arg1 = (wxWindow *) 0 ;
29151 PyObject * obj0 = 0 ;
29152 char *kwnames[] = {
29153 (char *) "self", NULL
29154 };
29155
29156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29158 if (SWIG_arg_fail(1)) SWIG_fail;
29159 {
29160 PyThreadState* __tstate = wxPyBeginAllowThreads();
29161 (arg1)->CaptureMouse();
29162
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 Py_INCREF(Py_None); resultobj = Py_None;
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj;
29175 wxWindow *arg1 = (wxWindow *) 0 ;
29176 PyObject * obj0 = 0 ;
29177 char *kwnames[] = {
29178 (char *) "self", NULL
29179 };
29180
29181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29183 if (SWIG_arg_fail(1)) SWIG_fail;
29184 {
29185 PyThreadState* __tstate = wxPyBeginAllowThreads();
29186 (arg1)->ReleaseMouse();
29187
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 Py_INCREF(Py_None); resultobj = Py_None;
29192 return resultobj;
29193 fail:
29194 return NULL;
29195 }
29196
29197
29198 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29199 PyObject *resultobj;
29200 wxWindow *result;
29201 char *kwnames[] = {
29202 NULL
29203 };
29204
29205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29206 {
29207 if (!wxPyCheckForApp()) SWIG_fail;
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 result = (wxWindow *)wxWindow::GetCapture();
29210
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 {
29215 resultobj = wxPyMake_wxObject(result, 0);
29216 }
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj;
29225 wxWindow *arg1 = (wxWindow *) 0 ;
29226 bool result;
29227 PyObject * obj0 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "self", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(1)) SWIG_fail;
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 result = (bool)((wxWindow const *)arg1)->HasCapture();
29238
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 {
29243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29244 }
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj;
29253 wxWindow *arg1 = (wxWindow *) 0 ;
29254 bool arg2 = (bool) true ;
29255 wxRect *arg3 = (wxRect *) NULL ;
29256 PyObject * obj0 = 0 ;
29257 PyObject * obj1 = 0 ;
29258 PyObject * obj2 = 0 ;
29259 char *kwnames[] = {
29260 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29261 };
29262
29263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29265 if (SWIG_arg_fail(1)) SWIG_fail;
29266 if (obj1) {
29267 {
29268 arg2 = (bool)(SWIG_As_bool(obj1));
29269 if (SWIG_arg_fail(2)) SWIG_fail;
29270 }
29271 }
29272 if (obj2) {
29273 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29274 if (SWIG_arg_fail(3)) SWIG_fail;
29275 }
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 Py_INCREF(Py_None); resultobj = Py_None;
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj;
29292 wxWindow *arg1 = (wxWindow *) 0 ;
29293 wxRect *arg2 = 0 ;
29294 bool arg3 = (bool) true ;
29295 wxRect temp2 ;
29296 PyObject * obj0 = 0 ;
29297 PyObject * obj1 = 0 ;
29298 PyObject * obj2 = 0 ;
29299 char *kwnames[] = {
29300 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29301 };
29302
29303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29305 if (SWIG_arg_fail(1)) SWIG_fail;
29306 {
29307 arg2 = &temp2;
29308 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29309 }
29310 if (obj2) {
29311 {
29312 arg3 = (bool)(SWIG_As_bool(obj2));
29313 if (SWIG_arg_fail(3)) SWIG_fail;
29314 }
29315 }
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29319
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 Py_INCREF(Py_None); resultobj = Py_None;
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj;
29332 wxWindow *arg1 = (wxWindow *) 0 ;
29333 PyObject * obj0 = 0 ;
29334 char *kwnames[] = {
29335 (char *) "self", NULL
29336 };
29337
29338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29340 if (SWIG_arg_fail(1)) SWIG_fail;
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 (arg1)->Update();
29344
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 Py_INCREF(Py_None); resultobj = Py_None;
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj;
29357 wxWindow *arg1 = (wxWindow *) 0 ;
29358 PyObject * obj0 = 0 ;
29359 char *kwnames[] = {
29360 (char *) "self", NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(1)) SWIG_fail;
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 (arg1)->ClearBackground();
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 Py_INCREF(Py_None); resultobj = Py_None;
29374 return resultobj;
29375 fail:
29376 return NULL;
29377 }
29378
29379
29380 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj;
29382 wxWindow *arg1 = (wxWindow *) 0 ;
29383 PyObject * obj0 = 0 ;
29384 char *kwnames[] = {
29385 (char *) "self", NULL
29386 };
29387
29388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29390 if (SWIG_arg_fail(1)) SWIG_fail;
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 (arg1)->Freeze();
29394
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 Py_INCREF(Py_None); resultobj = Py_None;
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29406 PyObject *resultobj;
29407 wxWindow *arg1 = (wxWindow *) 0 ;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 (arg1)->Thaw();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 Py_INCREF(Py_None); resultobj = Py_None;
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj;
29432 wxWindow *arg1 = (wxWindow *) 0 ;
29433 wxDC *arg2 = 0 ;
29434 PyObject * obj0 = 0 ;
29435 PyObject * obj1 = 0 ;
29436 char *kwnames[] = {
29437 (char *) "self",(char *) "dc", NULL
29438 };
29439
29440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29442 if (SWIG_arg_fail(1)) SWIG_fail;
29443 {
29444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29445 if (SWIG_arg_fail(2)) SWIG_fail;
29446 if (arg2 == NULL) {
29447 SWIG_null_ref("wxDC");
29448 }
29449 if (SWIG_arg_fail(2)) SWIG_fail;
29450 }
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 (arg1)->PrepareDC(*arg2);
29454
29455 wxPyEndAllowThreads(__tstate);
29456 if (PyErr_Occurred()) SWIG_fail;
29457 }
29458 Py_INCREF(Py_None); resultobj = Py_None;
29459 return resultobj;
29460 fail:
29461 return NULL;
29462 }
29463
29464
29465 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29466 PyObject *resultobj;
29467 wxWindow *arg1 = (wxWindow *) 0 ;
29468 wxRegion *result;
29469 PyObject * obj0 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 {
29480 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29481 result = (wxRegion *) &_result_ref;
29482 }
29483
29484 wxPyEndAllowThreads(__tstate);
29485 if (PyErr_Occurred()) SWIG_fail;
29486 }
29487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29488 return resultobj;
29489 fail:
29490 return NULL;
29491 }
29492
29493
29494 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29495 PyObject *resultobj;
29496 wxWindow *arg1 = (wxWindow *) 0 ;
29497 wxRect result;
29498 PyObject * obj0 = 0 ;
29499 char *kwnames[] = {
29500 (char *) "self", NULL
29501 };
29502
29503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29505 if (SWIG_arg_fail(1)) SWIG_fail;
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29509
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 {
29514 wxRect * resultptr;
29515 resultptr = new wxRect((wxRect &)(result));
29516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29525 PyObject *resultobj;
29526 wxWindow *arg1 = (wxWindow *) 0 ;
29527 int arg2 ;
29528 int arg3 ;
29529 int arg4 = (int) 1 ;
29530 int arg5 = (int) 1 ;
29531 bool result;
29532 PyObject * obj0 = 0 ;
29533 PyObject * obj1 = 0 ;
29534 PyObject * obj2 = 0 ;
29535 PyObject * obj3 = 0 ;
29536 PyObject * obj4 = 0 ;
29537 char *kwnames[] = {
29538 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29539 };
29540
29541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29543 if (SWIG_arg_fail(1)) SWIG_fail;
29544 {
29545 arg2 = (int)(SWIG_As_int(obj1));
29546 if (SWIG_arg_fail(2)) SWIG_fail;
29547 }
29548 {
29549 arg3 = (int)(SWIG_As_int(obj2));
29550 if (SWIG_arg_fail(3)) SWIG_fail;
29551 }
29552 if (obj3) {
29553 {
29554 arg4 = (int)(SWIG_As_int(obj3));
29555 if (SWIG_arg_fail(4)) SWIG_fail;
29556 }
29557 }
29558 if (obj4) {
29559 {
29560 arg5 = (int)(SWIG_As_int(obj4));
29561 if (SWIG_arg_fail(5)) SWIG_fail;
29562 }
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxWindow *arg1 = (wxWindow *) 0 ;
29583 wxPoint *arg2 = 0 ;
29584 bool result;
29585 wxPoint temp2 ;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 char *kwnames[] = {
29589 (char *) "self",(char *) "pt", NULL
29590 };
29591
29592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29594 if (SWIG_arg_fail(1)) SWIG_fail;
29595 {
29596 arg2 = &temp2;
29597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29598 }
29599 {
29600 PyThreadState* __tstate = wxPyBeginAllowThreads();
29601 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29602
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 {
29607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29608 }
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj;
29617 wxWindow *arg1 = (wxWindow *) 0 ;
29618 wxRect *arg2 = 0 ;
29619 bool result;
29620 wxRect temp2 ;
29621 PyObject * obj0 = 0 ;
29622 PyObject * obj1 = 0 ;
29623 char *kwnames[] = {
29624 (char *) "self",(char *) "rect", NULL
29625 };
29626
29627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29629 if (SWIG_arg_fail(1)) SWIG_fail;
29630 {
29631 arg2 = &temp2;
29632 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29633 }
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 {
29642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29643 }
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29651 PyObject *resultobj;
29652 wxWindow *arg1 = (wxWindow *) 0 ;
29653 wxVisualAttributes result;
29654 PyObject * obj0 = 0 ;
29655 char *kwnames[] = {
29656 (char *) "self", NULL
29657 };
29658
29659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29665
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 {
29670 wxVisualAttributes * resultptr;
29671 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29673 }
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29681 PyObject *resultobj;
29682 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29683 wxVisualAttributes result;
29684 PyObject * obj0 = 0 ;
29685 char *kwnames[] = {
29686 (char *) "variant", NULL
29687 };
29688
29689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29690 if (obj0) {
29691 {
29692 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 }
29695 }
29696 {
29697 if (!wxPyCheckForApp()) SWIG_fail;
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29700
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 {
29705 wxVisualAttributes * resultptr;
29706 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29708 }
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj;
29717 wxWindow *arg1 = (wxWindow *) 0 ;
29718 wxColour *arg2 = 0 ;
29719 bool result;
29720 wxColour temp2 ;
29721 PyObject * obj0 = 0 ;
29722 PyObject * obj1 = 0 ;
29723 char *kwnames[] = {
29724 (char *) "self",(char *) "colour", NULL
29725 };
29726
29727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29729 if (SWIG_arg_fail(1)) SWIG_fail;
29730 {
29731 arg2 = &temp2;
29732 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29733 }
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29737
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 {
29742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29743 }
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj;
29752 wxWindow *arg1 = (wxWindow *) 0 ;
29753 wxColour *arg2 = 0 ;
29754 wxColour temp2 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char *kwnames[] = {
29758 (char *) "self",(char *) "colour", NULL
29759 };
29760
29761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29763 if (SWIG_arg_fail(1)) SWIG_fail;
29764 {
29765 arg2 = &temp2;
29766 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29767 }
29768 {
29769 PyThreadState* __tstate = wxPyBeginAllowThreads();
29770 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29771
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 Py_INCREF(Py_None); resultobj = Py_None;
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxWindow *arg1 = (wxWindow *) 0 ;
29785 wxColour *arg2 = 0 ;
29786 bool result;
29787 wxColour temp2 ;
29788 PyObject * obj0 = 0 ;
29789 PyObject * obj1 = 0 ;
29790 char *kwnames[] = {
29791 (char *) "self",(char *) "colour", NULL
29792 };
29793
29794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29796 if (SWIG_arg_fail(1)) SWIG_fail;
29797 {
29798 arg2 = &temp2;
29799 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29800 }
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29804
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 {
29809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29810 }
29811 return resultobj;
29812 fail:
29813 return NULL;
29814 }
29815
29816
29817 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29818 PyObject *resultobj;
29819 wxWindow *arg1 = (wxWindow *) 0 ;
29820 wxColour *arg2 = 0 ;
29821 wxColour temp2 ;
29822 PyObject * obj0 = 0 ;
29823 PyObject * obj1 = 0 ;
29824 char *kwnames[] = {
29825 (char *) "self",(char *) "colour", NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29830 if (SWIG_arg_fail(1)) SWIG_fail;
29831 {
29832 arg2 = &temp2;
29833 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29834 }
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29838
29839 wxPyEndAllowThreads(__tstate);
29840 if (PyErr_Occurred()) SWIG_fail;
29841 }
29842 Py_INCREF(Py_None); resultobj = Py_None;
29843 return resultobj;
29844 fail:
29845 return NULL;
29846 }
29847
29848
29849 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj;
29851 wxWindow *arg1 = (wxWindow *) 0 ;
29852 wxColour result;
29853 PyObject * obj0 = 0 ;
29854 char *kwnames[] = {
29855 (char *) "self", NULL
29856 };
29857
29858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29860 if (SWIG_arg_fail(1)) SWIG_fail;
29861 {
29862 PyThreadState* __tstate = wxPyBeginAllowThreads();
29863 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29864
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 {
29869 wxColour * resultptr;
29870 resultptr = new wxColour((wxColour &)(result));
29871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29872 }
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj;
29881 wxWindow *arg1 = (wxWindow *) 0 ;
29882 wxColour result;
29883 PyObject * obj0 = 0 ;
29884 char *kwnames[] = {
29885 (char *) "self", NULL
29886 };
29887
29888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29890 if (SWIG_arg_fail(1)) SWIG_fail;
29891 {
29892 PyThreadState* __tstate = wxPyBeginAllowThreads();
29893 result = ((wxWindow const *)arg1)->GetForegroundColour();
29894
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 {
29899 wxColour * resultptr;
29900 resultptr = new wxColour((wxColour &)(result));
29901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29902 }
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj;
29911 wxWindow *arg1 = (wxWindow *) 0 ;
29912 bool result;
29913 PyObject * obj0 = 0 ;
29914 char *kwnames[] = {
29915 (char *) "self", NULL
29916 };
29917
29918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29920 if (SWIG_arg_fail(1)) SWIG_fail;
29921 {
29922 PyThreadState* __tstate = wxPyBeginAllowThreads();
29923 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29924
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 {
29929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29930 }
29931 return resultobj;
29932 fail:
29933 return NULL;
29934 }
29935
29936
29937 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29938 PyObject *resultobj;
29939 wxWindow *arg1 = (wxWindow *) 0 ;
29940 bool result;
29941 PyObject * obj0 = 0 ;
29942 char *kwnames[] = {
29943 (char *) "self", NULL
29944 };
29945
29946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29948 if (SWIG_arg_fail(1)) SWIG_fail;
29949 {
29950 PyThreadState* __tstate = wxPyBeginAllowThreads();
29951 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29952
29953 wxPyEndAllowThreads(__tstate);
29954 if (PyErr_Occurred()) SWIG_fail;
29955 }
29956 {
29957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29958 }
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj;
29967 wxWindow *arg1 = (wxWindow *) 0 ;
29968 wxBackgroundStyle arg2 ;
29969 bool result;
29970 PyObject * obj0 = 0 ;
29971 PyObject * obj1 = 0 ;
29972 char *kwnames[] = {
29973 (char *) "self",(char *) "style", NULL
29974 };
29975
29976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29978 if (SWIG_arg_fail(1)) SWIG_fail;
29979 {
29980 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29981 if (SWIG_arg_fail(2)) SWIG_fail;
29982 }
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29986
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 {
29991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29992 }
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj;
30001 wxWindow *arg1 = (wxWindow *) 0 ;
30002 wxBackgroundStyle result;
30003 PyObject * obj0 = 0 ;
30004 char *kwnames[] = {
30005 (char *) "self", NULL
30006 };
30007
30008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
30013 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30014
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 resultobj = SWIG_From_int((result));
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30026 PyObject *resultobj;
30027 wxWindow *arg1 = (wxWindow *) 0 ;
30028 bool result;
30029 PyObject * obj0 = 0 ;
30030 char *kwnames[] = {
30031 (char *) "self", NULL
30032 };
30033
30034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30036 if (SWIG_arg_fail(1)) SWIG_fail;
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = (bool)(arg1)->HasTransparentBackground();
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 {
30045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30046 }
30047 return resultobj;
30048 fail:
30049 return NULL;
30050 }
30051
30052
30053 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30054 PyObject *resultobj;
30055 wxWindow *arg1 = (wxWindow *) 0 ;
30056 wxCursor *arg2 = 0 ;
30057 bool result;
30058 PyObject * obj0 = 0 ;
30059 PyObject * obj1 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self",(char *) "cursor", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(1)) SWIG_fail;
30067 {
30068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(2)) SWIG_fail;
30070 if (arg2 == NULL) {
30071 SWIG_null_ref("wxCursor");
30072 }
30073 if (SWIG_arg_fail(2)) SWIG_fail;
30074 }
30075 {
30076 PyThreadState* __tstate = wxPyBeginAllowThreads();
30077 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30078
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 {
30083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30084 }
30085 return resultobj;
30086 fail:
30087 return NULL;
30088 }
30089
30090
30091 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30092 PyObject *resultobj;
30093 wxWindow *arg1 = (wxWindow *) 0 ;
30094 wxCursor result;
30095 PyObject * obj0 = 0 ;
30096 char *kwnames[] = {
30097 (char *) "self", NULL
30098 };
30099
30100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30102 if (SWIG_arg_fail(1)) SWIG_fail;
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (arg1)->GetCursor();
30106
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 {
30111 wxCursor * resultptr;
30112 resultptr = new wxCursor((wxCursor &)(result));
30113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30114 }
30115 return resultobj;
30116 fail:
30117 return NULL;
30118 }
30119
30120
30121 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30122 PyObject *resultobj;
30123 wxWindow *arg1 = (wxWindow *) 0 ;
30124 wxFont *arg2 = 0 ;
30125 bool result;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "self",(char *) "font", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30137 if (SWIG_arg_fail(2)) SWIG_fail;
30138 if (arg2 == NULL) {
30139 SWIG_null_ref("wxFont");
30140 }
30141 if (SWIG_arg_fail(2)) SWIG_fail;
30142 }
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30146
30147 wxPyEndAllowThreads(__tstate);
30148 if (PyErr_Occurred()) SWIG_fail;
30149 }
30150 {
30151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30152 }
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30160 PyObject *resultobj;
30161 wxWindow *arg1 = (wxWindow *) 0 ;
30162 wxFont *arg2 = 0 ;
30163 PyObject * obj0 = 0 ;
30164 PyObject * obj1 = 0 ;
30165 char *kwnames[] = {
30166 (char *) "self",(char *) "font", NULL
30167 };
30168
30169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30171 if (SWIG_arg_fail(1)) SWIG_fail;
30172 {
30173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30174 if (SWIG_arg_fail(2)) SWIG_fail;
30175 if (arg2 == NULL) {
30176 SWIG_null_ref("wxFont");
30177 }
30178 if (SWIG_arg_fail(2)) SWIG_fail;
30179 }
30180 {
30181 PyThreadState* __tstate = wxPyBeginAllowThreads();
30182 (arg1)->SetOwnFont((wxFont const &)*arg2);
30183
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 Py_INCREF(Py_None); resultobj = Py_None;
30188 return resultobj;
30189 fail:
30190 return NULL;
30191 }
30192
30193
30194 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30195 PyObject *resultobj;
30196 wxWindow *arg1 = (wxWindow *) 0 ;
30197 wxFont result;
30198 PyObject * obj0 = 0 ;
30199 char *kwnames[] = {
30200 (char *) "self", NULL
30201 };
30202
30203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30205 if (SWIG_arg_fail(1)) SWIG_fail;
30206 {
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 result = (arg1)->GetFont();
30209
30210 wxPyEndAllowThreads(__tstate);
30211 if (PyErr_Occurred()) SWIG_fail;
30212 }
30213 {
30214 wxFont * resultptr;
30215 resultptr = new wxFont((wxFont &)(result));
30216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30217 }
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj;
30226 wxWindow *arg1 = (wxWindow *) 0 ;
30227 wxCaret *arg2 = (wxCaret *) 0 ;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 char *kwnames[] = {
30231 (char *) "self",(char *) "caret", NULL
30232 };
30233
30234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30236 if (SWIG_arg_fail(1)) SWIG_fail;
30237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30238 if (SWIG_arg_fail(2)) SWIG_fail;
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 (arg1)->SetCaret(arg2);
30242
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 Py_INCREF(Py_None); resultobj = Py_None;
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj;
30255 wxWindow *arg1 = (wxWindow *) 0 ;
30256 wxCaret *result;
30257 PyObject * obj0 = 0 ;
30258 char *kwnames[] = {
30259 (char *) "self", NULL
30260 };
30261
30262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30264 if (SWIG_arg_fail(1)) SWIG_fail;
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30268
30269 wxPyEndAllowThreads(__tstate);
30270 if (PyErr_Occurred()) SWIG_fail;
30271 }
30272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30273 return resultobj;
30274 fail:
30275 return NULL;
30276 }
30277
30278
30279 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30280 PyObject *resultobj;
30281 wxWindow *arg1 = (wxWindow *) 0 ;
30282 int result;
30283 PyObject * obj0 = 0 ;
30284 char *kwnames[] = {
30285 (char *) "self", NULL
30286 };
30287
30288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30290 if (SWIG_arg_fail(1)) SWIG_fail;
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30294
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 {
30299 resultobj = SWIG_From_int((int)(result));
30300 }
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 int result;
30311 PyObject * obj0 = 0 ;
30312 char *kwnames[] = {
30313 (char *) "self", NULL
30314 };
30315
30316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30318 if (SWIG_arg_fail(1)) SWIG_fail;
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30322
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 {
30327 resultobj = SWIG_From_int((int)(result));
30328 }
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30336 PyObject *resultobj;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 wxString *arg2 = 0 ;
30339 int *arg3 = (int *) 0 ;
30340 int *arg4 = (int *) 0 ;
30341 bool temp2 = false ;
30342 int temp3 ;
30343 int res3 = 0 ;
30344 int temp4 ;
30345 int res4 = 0 ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "self",(char *) "string", NULL
30350 };
30351
30352 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30353 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30356 if (SWIG_arg_fail(1)) SWIG_fail;
30357 {
30358 arg2 = wxString_in_helper(obj1);
30359 if (arg2 == NULL) SWIG_fail;
30360 temp2 = true;
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30365
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 Py_INCREF(Py_None); resultobj = Py_None;
30370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30372 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30373 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30374 {
30375 if (temp2)
30376 delete arg2;
30377 }
30378 return resultobj;
30379 fail:
30380 {
30381 if (temp2)
30382 delete arg2;
30383 }
30384 return NULL;
30385 }
30386
30387
30388 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 wxString *arg2 = 0 ;
30392 int *arg3 = (int *) 0 ;
30393 int *arg4 = (int *) 0 ;
30394 int *arg5 = (int *) 0 ;
30395 int *arg6 = (int *) 0 ;
30396 wxFont *arg7 = (wxFont *) NULL ;
30397 bool temp2 = false ;
30398 int temp3 ;
30399 int res3 = 0 ;
30400 int temp4 ;
30401 int res4 = 0 ;
30402 int temp5 ;
30403 int res5 = 0 ;
30404 int temp6 ;
30405 int res6 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self",(char *) "string",(char *) "font", NULL
30411 };
30412
30413 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30414 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30415 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30416 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30419 if (SWIG_arg_fail(1)) SWIG_fail;
30420 {
30421 arg2 = wxString_in_helper(obj1);
30422 if (arg2 == NULL) SWIG_fail;
30423 temp2 = true;
30424 }
30425 if (obj2) {
30426 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30427 if (SWIG_arg_fail(7)) SWIG_fail;
30428 }
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30432
30433 wxPyEndAllowThreads(__tstate);
30434 if (PyErr_Occurred()) SWIG_fail;
30435 }
30436 Py_INCREF(Py_None); resultobj = Py_None;
30437 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30438 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30439 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30440 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30441 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30442 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30443 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30444 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30445 {
30446 if (temp2)
30447 delete arg2;
30448 }
30449 return resultobj;
30450 fail:
30451 {
30452 if (temp2)
30453 delete arg2;
30454 }
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxWindow *arg1 = (wxWindow *) 0 ;
30462 int *arg2 = (int *) 0 ;
30463 int *arg3 = (int *) 0 ;
30464 int temp2 ;
30465 int res2 = 0 ;
30466 int temp3 ;
30467 int res3 = 0 ;
30468 PyObject * obj0 = 0 ;
30469 PyObject * obj1 = 0 ;
30470 PyObject * obj2 = 0 ;
30471 char *kwnames[] = {
30472 (char *) "self",(char *) "x",(char *) "y", NULL
30473 };
30474
30475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30477 if (SWIG_arg_fail(1)) SWIG_fail;
30478 {
30479 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30480 temp2 = SWIG_As_int(obj1);
30481 if (SWIG_arg_fail(2)) SWIG_fail;
30482 arg2 = &temp2;
30483 res2 = SWIG_NEWOBJ;
30484 }
30485 }
30486 {
30487 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30488 temp3 = SWIG_As_int(obj2);
30489 if (SWIG_arg_fail(3)) SWIG_fail;
30490 arg3 = &temp3;
30491 res3 = SWIG_NEWOBJ;
30492 }
30493 }
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30497
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 Py_INCREF(Py_None); resultobj = Py_None;
30502 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30503 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30504 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30505 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj;
30514 wxWindow *arg1 = (wxWindow *) 0 ;
30515 int *arg2 = (int *) 0 ;
30516 int *arg3 = (int *) 0 ;
30517 int temp2 ;
30518 int res2 = 0 ;
30519 int temp3 ;
30520 int res3 = 0 ;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 PyObject * obj2 = 0 ;
30524 char *kwnames[] = {
30525 (char *) "self",(char *) "x",(char *) "y", NULL
30526 };
30527
30528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30530 if (SWIG_arg_fail(1)) SWIG_fail;
30531 {
30532 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30533 temp2 = SWIG_As_int(obj1);
30534 if (SWIG_arg_fail(2)) SWIG_fail;
30535 arg2 = &temp2;
30536 res2 = SWIG_NEWOBJ;
30537 }
30538 }
30539 {
30540 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30541 temp3 = SWIG_As_int(obj2);
30542 if (SWIG_arg_fail(3)) SWIG_fail;
30543 arg3 = &temp3;
30544 res3 = SWIG_NEWOBJ;
30545 }
30546 }
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30550
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 Py_INCREF(Py_None); resultobj = Py_None;
30555 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30556 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30557 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30558 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30566 PyObject *resultobj;
30567 wxWindow *arg1 = (wxWindow *) 0 ;
30568 wxPoint *arg2 = 0 ;
30569 wxPoint result;
30570 wxPoint temp2 ;
30571 PyObject * obj0 = 0 ;
30572 PyObject * obj1 = 0 ;
30573 char *kwnames[] = {
30574 (char *) "self",(char *) "pt", NULL
30575 };
30576
30577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30579 if (SWIG_arg_fail(1)) SWIG_fail;
30580 {
30581 arg2 = &temp2;
30582 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30583 }
30584 {
30585 PyThreadState* __tstate = wxPyBeginAllowThreads();
30586 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30587
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 {
30592 wxPoint * resultptr;
30593 resultptr = new wxPoint((wxPoint &)(result));
30594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30595 }
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj;
30604 wxWindow *arg1 = (wxWindow *) 0 ;
30605 wxPoint *arg2 = 0 ;
30606 wxPoint result;
30607 wxPoint temp2 ;
30608 PyObject * obj0 = 0 ;
30609 PyObject * obj1 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self",(char *) "pt", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 {
30618 arg2 = &temp2;
30619 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30620 }
30621 {
30622 PyThreadState* __tstate = wxPyBeginAllowThreads();
30623 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30624
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 {
30629 wxPoint * resultptr;
30630 resultptr = new wxPoint((wxPoint &)(result));
30631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30632 }
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj;
30641 wxWindow *arg1 = (wxWindow *) 0 ;
30642 int arg2 ;
30643 int arg3 ;
30644 wxHitTest result;
30645 PyObject * obj0 = 0 ;
30646 PyObject * obj1 = 0 ;
30647 PyObject * obj2 = 0 ;
30648 char *kwnames[] = {
30649 (char *) "self",(char *) "x",(char *) "y", NULL
30650 };
30651
30652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30654 if (SWIG_arg_fail(1)) SWIG_fail;
30655 {
30656 arg2 = (int)(SWIG_As_int(obj1));
30657 if (SWIG_arg_fail(2)) SWIG_fail;
30658 }
30659 {
30660 arg3 = (int)(SWIG_As_int(obj2));
30661 if (SWIG_arg_fail(3)) SWIG_fail;
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30666
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_From_int((result));
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxPoint *arg2 = 0 ;
30681 wxHitTest result;
30682 wxPoint temp2 ;
30683 PyObject * obj0 = 0 ;
30684 PyObject * obj1 = 0 ;
30685 char *kwnames[] = {
30686 (char *) "self",(char *) "pt", NULL
30687 };
30688
30689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30691 if (SWIG_arg_fail(1)) SWIG_fail;
30692 {
30693 arg2 = &temp2;
30694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30695 }
30696 {
30697 PyThreadState* __tstate = wxPyBeginAllowThreads();
30698 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30699
30700 wxPyEndAllowThreads(__tstate);
30701 if (PyErr_Occurred()) SWIG_fail;
30702 }
30703 resultobj = SWIG_From_int((result));
30704 return resultobj;
30705 fail:
30706 return NULL;
30707 }
30708
30709
30710 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30711 PyObject *resultobj;
30712 wxWindow *arg1 = (wxWindow *) 0 ;
30713 long arg2 ;
30714 wxBorder result;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717
30718 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30720 if (SWIG_arg_fail(1)) SWIG_fail;
30721 {
30722 arg2 = (long)(SWIG_As_long(obj1));
30723 if (SWIG_arg_fail(2)) SWIG_fail;
30724 }
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30728
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 resultobj = SWIG_From_int((result));
30733 return resultobj;
30734 fail:
30735 return NULL;
30736 }
30737
30738
30739 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30740 PyObject *resultobj;
30741 wxWindow *arg1 = (wxWindow *) 0 ;
30742 wxBorder result;
30743 PyObject * obj0 = 0 ;
30744
30745 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30747 if (SWIG_arg_fail(1)) SWIG_fail;
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30751
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 resultobj = SWIG_From_int((result));
30756 return resultobj;
30757 fail:
30758 return NULL;
30759 }
30760
30761
30762 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30763 int argc;
30764 PyObject *argv[3];
30765 int ii;
30766
30767 argc = PyObject_Length(args);
30768 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30769 argv[ii] = PyTuple_GetItem(args,ii);
30770 }
30771 if (argc == 1) {
30772 int _v;
30773 {
30774 void *ptr;
30775 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30776 _v = 0;
30777 PyErr_Clear();
30778 } else {
30779 _v = 1;
30780 }
30781 }
30782 if (_v) {
30783 return _wrap_Window_GetBorder__SWIG_1(self,args);
30784 }
30785 }
30786 if (argc == 2) {
30787 int _v;
30788 {
30789 void *ptr;
30790 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30791 _v = 0;
30792 PyErr_Clear();
30793 } else {
30794 _v = 1;
30795 }
30796 }
30797 if (_v) {
30798 _v = SWIG_Check_long(argv[1]);
30799 if (_v) {
30800 return _wrap_Window_GetBorder__SWIG_0(self,args);
30801 }
30802 }
30803 }
30804
30805 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30806 return NULL;
30807 }
30808
30809
30810 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj;
30812 wxWindow *arg1 = (wxWindow *) 0 ;
30813 long arg2 = (long) wxUPDATE_UI_NONE ;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 char *kwnames[] = {
30817 (char *) "self",(char *) "flags", NULL
30818 };
30819
30820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(1)) SWIG_fail;
30823 if (obj1) {
30824 {
30825 arg2 = (long)(SWIG_As_long(obj1));
30826 if (SWIG_arg_fail(2)) SWIG_fail;
30827 }
30828 }
30829 {
30830 PyThreadState* __tstate = wxPyBeginAllowThreads();
30831 (arg1)->UpdateWindowUI(arg2);
30832
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 Py_INCREF(Py_None); resultobj = Py_None;
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30844 PyObject *resultobj;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 wxMenu *arg2 = (wxMenu *) 0 ;
30847 int arg3 = (int) -1 ;
30848 int arg4 = (int) -1 ;
30849 bool result;
30850 PyObject * obj0 = 0 ;
30851 PyObject * obj1 = 0 ;
30852 PyObject * obj2 = 0 ;
30853 PyObject * obj3 = 0 ;
30854 char *kwnames[] = {
30855 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30856 };
30857
30858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30860 if (SWIG_arg_fail(1)) SWIG_fail;
30861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30862 if (SWIG_arg_fail(2)) SWIG_fail;
30863 if (obj2) {
30864 {
30865 arg3 = (int)(SWIG_As_int(obj2));
30866 if (SWIG_arg_fail(3)) SWIG_fail;
30867 }
30868 }
30869 if (obj3) {
30870 {
30871 arg4 = (int)(SWIG_As_int(obj3));
30872 if (SWIG_arg_fail(4)) SWIG_fail;
30873 }
30874 }
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30878
30879 wxPyEndAllowThreads(__tstate);
30880 if (PyErr_Occurred()) SWIG_fail;
30881 }
30882 {
30883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30884 }
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30892 PyObject *resultobj;
30893 wxWindow *arg1 = (wxWindow *) 0 ;
30894 wxMenu *arg2 = (wxMenu *) 0 ;
30895 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30896 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30897 bool result;
30898 wxPoint temp3 ;
30899 PyObject * obj0 = 0 ;
30900 PyObject * obj1 = 0 ;
30901 PyObject * obj2 = 0 ;
30902 char *kwnames[] = {
30903 (char *) "self",(char *) "menu",(char *) "pos", NULL
30904 };
30905
30906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30908 if (SWIG_arg_fail(1)) SWIG_fail;
30909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30910 if (SWIG_arg_fail(2)) SWIG_fail;
30911 if (obj2) {
30912 {
30913 arg3 = &temp3;
30914 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30915 }
30916 }
30917 {
30918 PyThreadState* __tstate = wxPyBeginAllowThreads();
30919 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30920
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 {
30925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30926 }
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 long result;
30937 PyObject * obj0 = 0 ;
30938 char *kwnames[] = {
30939 (char *) "self", NULL
30940 };
30941
30942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30944 if (SWIG_arg_fail(1)) SWIG_fail;
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 result = (long)wxWindow_GetHandle(arg1);
30948
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 {
30953 resultobj = SWIG_From_long((long)(result));
30954 }
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30962 PyObject *resultobj;
30963 wxWindow *arg1 = (wxWindow *) 0 ;
30964 long arg2 ;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "self",(char *) "handle", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 {
30975 arg2 = (long)(SWIG_As_long(obj1));
30976 if (SWIG_arg_fail(2)) SWIG_fail;
30977 }
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 wxWindow_AssociateHandle(arg1,arg2);
30981
30982 wxPyEndAllowThreads(__tstate);
30983 if (PyErr_Occurred()) SWIG_fail;
30984 }
30985 Py_INCREF(Py_None); resultobj = Py_None;
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj;
30994 wxWindow *arg1 = (wxWindow *) 0 ;
30995 PyObject * obj0 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 (arg1)->DissociateHandle();
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 Py_INCREF(Py_None); resultobj = Py_None;
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj;
31019 wxWindow *arg1 = (wxWindow *) 0 ;
31020 int arg2 ;
31021 bool result;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 char *kwnames[] = {
31025 (char *) "self",(char *) "orient", NULL
31026 };
31027
31028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31030 if (SWIG_arg_fail(1)) SWIG_fail;
31031 {
31032 arg2 = (int)(SWIG_As_int(obj1));
31033 if (SWIG_arg_fail(2)) SWIG_fail;
31034 }
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 {
31043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 int arg2 ;
31055 int arg3 ;
31056 int arg4 ;
31057 int arg5 ;
31058 bool arg6 = (bool) true ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 PyObject * obj3 = 0 ;
31063 PyObject * obj4 = 0 ;
31064 PyObject * obj5 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 arg2 = (int)(SWIG_As_int(obj1));
31074 if (SWIG_arg_fail(2)) SWIG_fail;
31075 }
31076 {
31077 arg3 = (int)(SWIG_As_int(obj2));
31078 if (SWIG_arg_fail(3)) SWIG_fail;
31079 }
31080 {
31081 arg4 = (int)(SWIG_As_int(obj3));
31082 if (SWIG_arg_fail(4)) SWIG_fail;
31083 }
31084 {
31085 arg5 = (int)(SWIG_As_int(obj4));
31086 if (SWIG_arg_fail(5)) SWIG_fail;
31087 }
31088 if (obj5) {
31089 {
31090 arg6 = (bool)(SWIG_As_bool(obj5));
31091 if (SWIG_arg_fail(6)) SWIG_fail;
31092 }
31093 }
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31097
31098 wxPyEndAllowThreads(__tstate);
31099 if (PyErr_Occurred()) SWIG_fail;
31100 }
31101 Py_INCREF(Py_None); resultobj = Py_None;
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31109 PyObject *resultobj;
31110 wxWindow *arg1 = (wxWindow *) 0 ;
31111 int arg2 ;
31112 int arg3 ;
31113 bool arg4 = (bool) true ;
31114 PyObject * obj0 = 0 ;
31115 PyObject * obj1 = 0 ;
31116 PyObject * obj2 = 0 ;
31117 PyObject * obj3 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 arg2 = (int)(SWIG_As_int(obj1));
31127 if (SWIG_arg_fail(2)) SWIG_fail;
31128 }
31129 {
31130 arg3 = (int)(SWIG_As_int(obj2));
31131 if (SWIG_arg_fail(3)) SWIG_fail;
31132 }
31133 if (obj3) {
31134 {
31135 arg4 = (bool)(SWIG_As_bool(obj3));
31136 if (SWIG_arg_fail(4)) SWIG_fail;
31137 }
31138 }
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 (arg1)->SetScrollPos(arg2,arg3,arg4);
31142
31143 wxPyEndAllowThreads(__tstate);
31144 if (PyErr_Occurred()) SWIG_fail;
31145 }
31146 Py_INCREF(Py_None); resultobj = Py_None;
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31154 PyObject *resultobj;
31155 wxWindow *arg1 = (wxWindow *) 0 ;
31156 int arg2 ;
31157 int result;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self",(char *) "orientation", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 {
31168 arg2 = (int)(SWIG_As_int(obj1));
31169 if (SWIG_arg_fail(2)) SWIG_fail;
31170 }
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31174
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 {
31179 resultobj = SWIG_From_int((int)(result));
31180 }
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 int arg2 ;
31191 int result;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "orientation", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = (int)(SWIG_As_int(obj1));
31203 if (SWIG_arg_fail(2)) SWIG_fail;
31204 }
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 {
31213 resultobj = SWIG_From_int((int)(result));
31214 }
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 int arg2 ;
31225 int result;
31226 PyObject * obj0 = 0 ;
31227 PyObject * obj1 = 0 ;
31228 char *kwnames[] = {
31229 (char *) "self",(char *) "orientation", NULL
31230 };
31231
31232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31234 if (SWIG_arg_fail(1)) SWIG_fail;
31235 {
31236 arg2 = (int)(SWIG_As_int(obj1));
31237 if (SWIG_arg_fail(2)) SWIG_fail;
31238 }
31239 {
31240 PyThreadState* __tstate = wxPyBeginAllowThreads();
31241 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31242
31243 wxPyEndAllowThreads(__tstate);
31244 if (PyErr_Occurred()) SWIG_fail;
31245 }
31246 {
31247 resultobj = SWIG_From_int((int)(result));
31248 }
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxWindow *arg1 = (wxWindow *) 0 ;
31258 int arg2 ;
31259 int arg3 ;
31260 wxRect *arg4 = (wxRect *) NULL ;
31261 PyObject * obj0 = 0 ;
31262 PyObject * obj1 = 0 ;
31263 PyObject * obj2 = 0 ;
31264 PyObject * obj3 = 0 ;
31265 char *kwnames[] = {
31266 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31267 };
31268
31269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31271 if (SWIG_arg_fail(1)) SWIG_fail;
31272 {
31273 arg2 = (int)(SWIG_As_int(obj1));
31274 if (SWIG_arg_fail(2)) SWIG_fail;
31275 }
31276 {
31277 arg3 = (int)(SWIG_As_int(obj2));
31278 if (SWIG_arg_fail(3)) SWIG_fail;
31279 }
31280 if (obj3) {
31281 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31282 if (SWIG_arg_fail(4)) SWIG_fail;
31283 }
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31287
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 Py_INCREF(Py_None); resultobj = Py_None;
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31299 PyObject *resultobj;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 int arg2 ;
31302 bool result;
31303 PyObject * obj0 = 0 ;
31304 PyObject * obj1 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self",(char *) "lines", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 {
31313 arg2 = (int)(SWIG_As_int(obj1));
31314 if (SWIG_arg_fail(2)) SWIG_fail;
31315 }
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = (bool)(arg1)->ScrollLines(arg2);
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 int arg2 ;
31336 bool result;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 char *kwnames[] = {
31340 (char *) "self",(char *) "pages", NULL
31341 };
31342
31343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31345 if (SWIG_arg_fail(1)) SWIG_fail;
31346 {
31347 arg2 = (int)(SWIG_As_int(obj1));
31348 if (SWIG_arg_fail(2)) SWIG_fail;
31349 }
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (bool)(arg1)->ScrollPages(arg2);
31353
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 {
31358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31359 }
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 bool result;
31370 PyObject * obj0 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31380 result = (bool)(arg1)->LineUp();
31381
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 {
31386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31387 }
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31395 PyObject *resultobj;
31396 wxWindow *arg1 = (wxWindow *) 0 ;
31397 bool result;
31398 PyObject * obj0 = 0 ;
31399 char *kwnames[] = {
31400 (char *) "self", NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31405 if (SWIG_arg_fail(1)) SWIG_fail;
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = (bool)(arg1)->LineDown();
31409
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 {
31414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31415 }
31416 return resultobj;
31417 fail:
31418 return NULL;
31419 }
31420
31421
31422 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31423 PyObject *resultobj;
31424 wxWindow *arg1 = (wxWindow *) 0 ;
31425 bool result;
31426 PyObject * obj0 = 0 ;
31427 char *kwnames[] = {
31428 (char *) "self", NULL
31429 };
31430
31431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31433 if (SWIG_arg_fail(1)) SWIG_fail;
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (bool)(arg1)->PageUp();
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 {
31442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 bool result;
31454 PyObject * obj0 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 result = (bool)(arg1)->PageDown();
31465
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 {
31470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31471 }
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31479 PyObject *resultobj;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 wxString *arg2 = 0 ;
31482 bool temp2 = false ;
31483 PyObject * obj0 = 0 ;
31484 PyObject * obj1 = 0 ;
31485 char *kwnames[] = {
31486 (char *) "self",(char *) "text", NULL
31487 };
31488
31489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31491 if (SWIG_arg_fail(1)) SWIG_fail;
31492 {
31493 arg2 = wxString_in_helper(obj1);
31494 if (arg2 == NULL) SWIG_fail;
31495 temp2 = true;
31496 }
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 (arg1)->SetHelpText((wxString const &)*arg2);
31500
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 Py_INCREF(Py_None); resultobj = Py_None;
31505 {
31506 if (temp2)
31507 delete arg2;
31508 }
31509 return resultobj;
31510 fail:
31511 {
31512 if (temp2)
31513 delete arg2;
31514 }
31515 return NULL;
31516 }
31517
31518
31519 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31520 PyObject *resultobj;
31521 wxWindow *arg1 = (wxWindow *) 0 ;
31522 wxString *arg2 = 0 ;
31523 bool temp2 = false ;
31524 PyObject * obj0 = 0 ;
31525 PyObject * obj1 = 0 ;
31526 char *kwnames[] = {
31527 (char *) "self",(char *) "text", NULL
31528 };
31529
31530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31532 if (SWIG_arg_fail(1)) SWIG_fail;
31533 {
31534 arg2 = wxString_in_helper(obj1);
31535 if (arg2 == NULL) SWIG_fail;
31536 temp2 = true;
31537 }
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31541
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 Py_INCREF(Py_None); resultobj = Py_None;
31546 {
31547 if (temp2)
31548 delete arg2;
31549 }
31550 return resultobj;
31551 fail:
31552 {
31553 if (temp2)
31554 delete arg2;
31555 }
31556 return NULL;
31557 }
31558
31559
31560 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31561 PyObject *resultobj;
31562 wxWindow *arg1 = (wxWindow *) 0 ;
31563 wxString result;
31564 PyObject * obj0 = 0 ;
31565 char *kwnames[] = {
31566 (char *) "self", NULL
31567 };
31568
31569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31571 if (SWIG_arg_fail(1)) SWIG_fail;
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = ((wxWindow const *)arg1)->GetHelpText();
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 {
31580 #if wxUSE_UNICODE
31581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31582 #else
31583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31584 #endif
31585 }
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 wxString *arg2 = 0 ;
31596 bool temp2 = false ;
31597 PyObject * obj0 = 0 ;
31598 PyObject * obj1 = 0 ;
31599 char *kwnames[] = {
31600 (char *) "self",(char *) "tip", NULL
31601 };
31602
31603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31605 if (SWIG_arg_fail(1)) SWIG_fail;
31606 {
31607 arg2 = wxString_in_helper(obj1);
31608 if (arg2 == NULL) SWIG_fail;
31609 temp2 = true;
31610 }
31611 {
31612 PyThreadState* __tstate = wxPyBeginAllowThreads();
31613 (arg1)->SetToolTip((wxString const &)*arg2);
31614
31615 wxPyEndAllowThreads(__tstate);
31616 if (PyErr_Occurred()) SWIG_fail;
31617 }
31618 Py_INCREF(Py_None); resultobj = Py_None;
31619 {
31620 if (temp2)
31621 delete arg2;
31622 }
31623 return resultobj;
31624 fail:
31625 {
31626 if (temp2)
31627 delete arg2;
31628 }
31629 return NULL;
31630 }
31631
31632
31633 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31634 PyObject *resultobj;
31635 wxWindow *arg1 = (wxWindow *) 0 ;
31636 wxToolTip *arg2 = (wxToolTip *) 0 ;
31637 PyObject * obj0 = 0 ;
31638 PyObject * obj1 = 0 ;
31639 char *kwnames[] = {
31640 (char *) "self",(char *) "tip", NULL
31641 };
31642
31643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31645 if (SWIG_arg_fail(1)) SWIG_fail;
31646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31647 if (SWIG_arg_fail(2)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 (arg1)->SetToolTip(arg2);
31651
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 Py_INCREF(Py_None); resultobj = Py_None;
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31663 PyObject *resultobj;
31664 wxWindow *arg1 = (wxWindow *) 0 ;
31665 wxToolTip *result;
31666 PyObject * obj0 = 0 ;
31667 char *kwnames[] = {
31668 (char *) "self", NULL
31669 };
31670
31671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31673 if (SWIG_arg_fail(1)) SWIG_fail;
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31677
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 {
31682 resultobj = wxPyMake_wxObject(result, 0);
31683 }
31684 return resultobj;
31685 fail:
31686 return NULL;
31687 }
31688
31689
31690 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31691 PyObject *resultobj;
31692 wxWindow *arg1 = (wxWindow *) 0 ;
31693 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 char *kwnames[] = {
31697 (char *) "self",(char *) "dropTarget", NULL
31698 };
31699
31700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31702 if (SWIG_arg_fail(1)) SWIG_fail;
31703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31704 if (SWIG_arg_fail(2)) SWIG_fail;
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 (arg1)->SetDropTarget(arg2);
31708
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 Py_INCREF(Py_None); resultobj = Py_None;
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31720 PyObject *resultobj;
31721 wxWindow *arg1 = (wxWindow *) 0 ;
31722 wxPyDropTarget *result;
31723 PyObject * obj0 = 0 ;
31724 char *kwnames[] = {
31725 (char *) "self", NULL
31726 };
31727
31728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31730 if (SWIG_arg_fail(1)) SWIG_fail;
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31734
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj;
31747 wxWindow *arg1 = (wxWindow *) 0 ;
31748 bool arg2 ;
31749 PyObject * obj0 = 0 ;
31750 PyObject * obj1 = 0 ;
31751 char *kwnames[] = {
31752 (char *) "self",(char *) "accept", NULL
31753 };
31754
31755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31757 if (SWIG_arg_fail(1)) SWIG_fail;
31758 {
31759 arg2 = (bool)(SWIG_As_bool(obj1));
31760 if (SWIG_arg_fail(2)) SWIG_fail;
31761 }
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 wxWindow_DragAcceptFiles(arg1,arg2);
31765
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 Py_INCREF(Py_None); resultobj = Py_None;
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31777 PyObject *resultobj;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31780 PyObject * obj0 = 0 ;
31781 PyObject * obj1 = 0 ;
31782 char *kwnames[] = {
31783 (char *) "self",(char *) "constraints", NULL
31784 };
31785
31786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31788 if (SWIG_arg_fail(1)) SWIG_fail;
31789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31790 if (SWIG_arg_fail(2)) SWIG_fail;
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 (arg1)->SetConstraints(arg2);
31794
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 Py_INCREF(Py_None); resultobj = Py_None;
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj;
31807 wxWindow *arg1 = (wxWindow *) 0 ;
31808 wxLayoutConstraints *result;
31809 PyObject * obj0 = 0 ;
31810 char *kwnames[] = {
31811 (char *) "self", NULL
31812 };
31813
31814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31816 if (SWIG_arg_fail(1)) SWIG_fail;
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31820
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31825 return resultobj;
31826 fail:
31827 return NULL;
31828 }
31829
31830
31831 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31832 PyObject *resultobj;
31833 wxWindow *arg1 = (wxWindow *) 0 ;
31834 bool arg2 ;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 char *kwnames[] = {
31838 (char *) "self",(char *) "autoLayout", NULL
31839 };
31840
31841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31843 if (SWIG_arg_fail(1)) SWIG_fail;
31844 {
31845 arg2 = (bool)(SWIG_As_bool(obj1));
31846 if (SWIG_arg_fail(2)) SWIG_fail;
31847 }
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 (arg1)->SetAutoLayout(arg2);
31851
31852 wxPyEndAllowThreads(__tstate);
31853 if (PyErr_Occurred()) SWIG_fail;
31854 }
31855 Py_INCREF(Py_None); resultobj = Py_None;
31856 return resultobj;
31857 fail:
31858 return NULL;
31859 }
31860
31861
31862 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31863 PyObject *resultobj;
31864 wxWindow *arg1 = (wxWindow *) 0 ;
31865 bool result;
31866 PyObject * obj0 = 0 ;
31867 char *kwnames[] = {
31868 (char *) "self", NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(1)) SWIG_fail;
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31877
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 wxWindow *arg1 = (wxWindow *) 0 ;
31893 bool result;
31894 PyObject * obj0 = 0 ;
31895 char *kwnames[] = {
31896 (char *) "self", NULL
31897 };
31898
31899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31901 if (SWIG_arg_fail(1)) SWIG_fail;
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = (bool)(arg1)->Layout();
31905
31906 wxPyEndAllowThreads(__tstate);
31907 if (PyErr_Occurred()) SWIG_fail;
31908 }
31909 {
31910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31911 }
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj;
31920 wxWindow *arg1 = (wxWindow *) 0 ;
31921 wxSizer *arg2 = (wxSizer *) 0 ;
31922 bool arg3 = (bool) true ;
31923 PyObject * obj0 = 0 ;
31924 PyObject * obj1 = 0 ;
31925 PyObject * obj2 = 0 ;
31926 char *kwnames[] = {
31927 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31928 };
31929
31930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31932 if (SWIG_arg_fail(1)) SWIG_fail;
31933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31934 if (SWIG_arg_fail(2)) SWIG_fail;
31935 if (obj2) {
31936 {
31937 arg3 = (bool)(SWIG_As_bool(obj2));
31938 if (SWIG_arg_fail(3)) SWIG_fail;
31939 }
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 (arg1)->SetSizer(arg2,arg3);
31944
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 Py_INCREF(Py_None); resultobj = Py_None;
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31956 PyObject *resultobj;
31957 wxWindow *arg1 = (wxWindow *) 0 ;
31958 wxSizer *arg2 = (wxSizer *) 0 ;
31959 bool arg3 = (bool) true ;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 PyObject * obj2 = 0 ;
31963 char *kwnames[] = {
31964 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31965 };
31966
31967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31969 if (SWIG_arg_fail(1)) SWIG_fail;
31970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31971 if (SWIG_arg_fail(2)) SWIG_fail;
31972 if (obj2) {
31973 {
31974 arg3 = (bool)(SWIG_As_bool(obj2));
31975 if (SWIG_arg_fail(3)) SWIG_fail;
31976 }
31977 }
31978 {
31979 PyThreadState* __tstate = wxPyBeginAllowThreads();
31980 (arg1)->SetSizerAndFit(arg2,arg3);
31981
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 Py_INCREF(Py_None); resultobj = Py_None;
31986 return resultobj;
31987 fail:
31988 return NULL;
31989 }
31990
31991
31992 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31993 PyObject *resultobj;
31994 wxWindow *arg1 = (wxWindow *) 0 ;
31995 wxSizer *result;
31996 PyObject * obj0 = 0 ;
31997 char *kwnames[] = {
31998 (char *) "self", NULL
31999 };
32000
32001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32003 if (SWIG_arg_fail(1)) SWIG_fail;
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32007
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 {
32012 resultobj = wxPyMake_wxObject(result, 0);
32013 }
32014 return resultobj;
32015 fail:
32016 return NULL;
32017 }
32018
32019
32020 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32021 PyObject *resultobj;
32022 wxWindow *arg1 = (wxWindow *) 0 ;
32023 wxSizer *arg2 = (wxSizer *) 0 ;
32024 PyObject * obj0 = 0 ;
32025 PyObject * obj1 = 0 ;
32026 char *kwnames[] = {
32027 (char *) "self",(char *) "sizer", NULL
32028 };
32029
32030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32032 if (SWIG_arg_fail(1)) SWIG_fail;
32033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32034 if (SWIG_arg_fail(2)) SWIG_fail;
32035 {
32036 PyThreadState* __tstate = wxPyBeginAllowThreads();
32037 (arg1)->SetContainingSizer(arg2);
32038
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 Py_INCREF(Py_None); resultobj = Py_None;
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 wxSizer *result;
32053 PyObject * obj0 = 0 ;
32054 char *kwnames[] = {
32055 (char *) "self", NULL
32056 };
32057
32058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32060 if (SWIG_arg_fail(1)) SWIG_fail;
32061 {
32062 PyThreadState* __tstate = wxPyBeginAllowThreads();
32063 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32064
32065 wxPyEndAllowThreads(__tstate);
32066 if (PyErr_Occurred()) SWIG_fail;
32067 }
32068 {
32069 resultobj = wxPyMake_wxObject(result, 0);
32070 }
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32078 PyObject *resultobj;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 PyObject * obj0 = 0 ;
32081 char *kwnames[] = {
32082 (char *) "self", NULL
32083 };
32084
32085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32087 if (SWIG_arg_fail(1)) SWIG_fail;
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 (arg1)->InheritAttributes();
32091
32092 wxPyEndAllowThreads(__tstate);
32093 if (PyErr_Occurred()) SWIG_fail;
32094 }
32095 Py_INCREF(Py_None); resultobj = Py_None;
32096 return resultobj;
32097 fail:
32098 return NULL;
32099 }
32100
32101
32102 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32103 PyObject *resultobj;
32104 wxWindow *arg1 = (wxWindow *) 0 ;
32105 bool result;
32106 PyObject * obj0 = 0 ;
32107 char *kwnames[] = {
32108 (char *) "self", NULL
32109 };
32110
32111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32113 if (SWIG_arg_fail(1)) SWIG_fail;
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32117
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 {
32122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32123 }
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32131 PyObject *obj;
32132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32133 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32134 Py_INCREF(obj);
32135 return Py_BuildValue((char *)"");
32136 }
32137 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32138 PyObject *resultobj;
32139 long arg1 ;
32140 wxWindow *arg2 = (wxWindow *) NULL ;
32141 wxWindow *result;
32142 PyObject * obj0 = 0 ;
32143 PyObject * obj1 = 0 ;
32144 char *kwnames[] = {
32145 (char *) "id",(char *) "parent", NULL
32146 };
32147
32148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32149 {
32150 arg1 = (long)(SWIG_As_long(obj0));
32151 if (SWIG_arg_fail(1)) SWIG_fail;
32152 }
32153 if (obj1) {
32154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32155 if (SWIG_arg_fail(2)) SWIG_fail;
32156 }
32157 {
32158 if (!wxPyCheckForApp()) SWIG_fail;
32159 PyThreadState* __tstate = wxPyBeginAllowThreads();
32160 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32161
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 {
32166 resultobj = wxPyMake_wxObject(result, 0);
32167 }
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32175 PyObject *resultobj;
32176 wxString *arg1 = 0 ;
32177 wxWindow *arg2 = (wxWindow *) NULL ;
32178 wxWindow *result;
32179 bool temp1 = false ;
32180 PyObject * obj0 = 0 ;
32181 PyObject * obj1 = 0 ;
32182 char *kwnames[] = {
32183 (char *) "name",(char *) "parent", NULL
32184 };
32185
32186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32187 {
32188 arg1 = wxString_in_helper(obj0);
32189 if (arg1 == NULL) SWIG_fail;
32190 temp1 = true;
32191 }
32192 if (obj1) {
32193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32194 if (SWIG_arg_fail(2)) SWIG_fail;
32195 }
32196 {
32197 if (!wxPyCheckForApp()) SWIG_fail;
32198 PyThreadState* __tstate = wxPyBeginAllowThreads();
32199 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32200
32201 wxPyEndAllowThreads(__tstate);
32202 if (PyErr_Occurred()) SWIG_fail;
32203 }
32204 {
32205 resultobj = wxPyMake_wxObject(result, 0);
32206 }
32207 {
32208 if (temp1)
32209 delete arg1;
32210 }
32211 return resultobj;
32212 fail:
32213 {
32214 if (temp1)
32215 delete arg1;
32216 }
32217 return NULL;
32218 }
32219
32220
32221 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32222 PyObject *resultobj;
32223 wxString *arg1 = 0 ;
32224 wxWindow *arg2 = (wxWindow *) NULL ;
32225 wxWindow *result;
32226 bool temp1 = false ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char *kwnames[] = {
32230 (char *) "label",(char *) "parent", NULL
32231 };
32232
32233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32234 {
32235 arg1 = wxString_in_helper(obj0);
32236 if (arg1 == NULL) SWIG_fail;
32237 temp1 = true;
32238 }
32239 if (obj1) {
32240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32241 if (SWIG_arg_fail(2)) SWIG_fail;
32242 }
32243 {
32244 if (!wxPyCheckForApp()) SWIG_fail;
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32247
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = wxPyMake_wxObject(result, 0);
32253 }
32254 {
32255 if (temp1)
32256 delete arg1;
32257 }
32258 return resultobj;
32259 fail:
32260 {
32261 if (temp1)
32262 delete arg1;
32263 }
32264 return NULL;
32265 }
32266
32267
32268 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32269 PyObject *resultobj;
32270 wxWindow *arg1 = (wxWindow *) 0 ;
32271 unsigned long arg2 ;
32272 wxWindow *result;
32273 PyObject * obj0 = 0 ;
32274 PyObject * obj1 = 0 ;
32275 char *kwnames[] = {
32276 (char *) "parent",(char *) "_hWnd", NULL
32277 };
32278
32279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32281 if (SWIG_arg_fail(1)) SWIG_fail;
32282 {
32283 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32284 if (SWIG_arg_fail(2)) SWIG_fail;
32285 }
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32289
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 {
32294 resultobj = wxPyMake_wxObject(result, 0);
32295 }
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj;
32304 PyObject *result;
32305 char *kwnames[] = {
32306 NULL
32307 };
32308
32309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (PyObject *)GetTopLevelWindows();
32313
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 resultobj = result;
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32325 PyObject *resultobj;
32326 wxValidator *result;
32327 char *kwnames[] = {
32328 NULL
32329 };
32330
32331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 result = (wxValidator *)new wxValidator();
32335
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32340 return resultobj;
32341 fail:
32342 return NULL;
32343 }
32344
32345
32346 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32347 PyObject *resultobj;
32348 wxValidator *arg1 = (wxValidator *) 0 ;
32349 wxValidator *result;
32350 PyObject * obj0 = 0 ;
32351 char *kwnames[] = {
32352 (char *) "self", NULL
32353 };
32354
32355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32357 if (SWIG_arg_fail(1)) SWIG_fail;
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 result = (wxValidator *)(arg1)->Clone();
32361
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 {
32366 resultobj = wxPyMake_wxObject(result, 0);
32367 }
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj;
32376 wxValidator *arg1 = (wxValidator *) 0 ;
32377 wxWindow *arg2 = (wxWindow *) 0 ;
32378 bool result;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 char *kwnames[] = {
32382 (char *) "self",(char *) "parent", NULL
32383 };
32384
32385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32387 if (SWIG_arg_fail(1)) SWIG_fail;
32388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32389 if (SWIG_arg_fail(2)) SWIG_fail;
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 result = (bool)(arg1)->Validate(arg2);
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 {
32398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32399 }
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32407 PyObject *resultobj;
32408 wxValidator *arg1 = (wxValidator *) 0 ;
32409 bool result;
32410 PyObject * obj0 = 0 ;
32411 char *kwnames[] = {
32412 (char *) "self", NULL
32413 };
32414
32415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32417 if (SWIG_arg_fail(1)) SWIG_fail;
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (bool)(arg1)->TransferToWindow();
32421
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 {
32426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32427 }
32428 return resultobj;
32429 fail:
32430 return NULL;
32431 }
32432
32433
32434 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32435 PyObject *resultobj;
32436 wxValidator *arg1 = (wxValidator *) 0 ;
32437 bool result;
32438 PyObject * obj0 = 0 ;
32439 char *kwnames[] = {
32440 (char *) "self", NULL
32441 };
32442
32443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32445 if (SWIG_arg_fail(1)) SWIG_fail;
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (bool)(arg1)->TransferFromWindow();
32449
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 {
32454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32455 }
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj;
32464 wxValidator *arg1 = (wxValidator *) 0 ;
32465 wxWindow *result;
32466 PyObject * obj0 = 0 ;
32467 char *kwnames[] = {
32468 (char *) "self", NULL
32469 };
32470
32471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32473 if (SWIG_arg_fail(1)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = (wxWindow *)(arg1)->GetWindow();
32477
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 {
32482 resultobj = wxPyMake_wxObject(result, 0);
32483 }
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32491 PyObject *resultobj;
32492 wxValidator *arg1 = (wxValidator *) 0 ;
32493 wxWindow *arg2 = (wxWindow *) 0 ;
32494 PyObject * obj0 = 0 ;
32495 PyObject * obj1 = 0 ;
32496 char *kwnames[] = {
32497 (char *) "self",(char *) "window", NULL
32498 };
32499
32500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32502 if (SWIG_arg_fail(1)) SWIG_fail;
32503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32504 if (SWIG_arg_fail(2)) SWIG_fail;
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 (arg1)->SetWindow(arg2);
32508
32509 wxPyEndAllowThreads(__tstate);
32510 if (PyErr_Occurred()) SWIG_fail;
32511 }
32512 Py_INCREF(Py_None); resultobj = Py_None;
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj;
32521 bool result;
32522 char *kwnames[] = {
32523 NULL
32524 };
32525
32526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = (bool)wxValidator::IsSilent();
32530
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 {
32535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32536 }
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj;
32545 int arg1 = (int) true ;
32546 PyObject * obj0 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "doIt", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32552 if (obj0) {
32553 {
32554 arg1 = (int)(SWIG_As_int(obj0));
32555 if (SWIG_arg_fail(1)) SWIG_fail;
32556 }
32557 }
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 wxValidator::SetBellOnError(arg1);
32561
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 Py_INCREF(Py_None); resultobj = Py_None;
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32573 PyObject *obj;
32574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32575 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32576 Py_INCREF(obj);
32577 return Py_BuildValue((char *)"");
32578 }
32579 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32580 PyObject *resultobj;
32581 wxPyValidator *result;
32582 char *kwnames[] = {
32583 NULL
32584 };
32585
32586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 result = (wxPyValidator *)new wxPyValidator();
32590
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj;
32603 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32604 PyObject *arg2 = (PyObject *) 0 ;
32605 PyObject *arg3 = (PyObject *) 0 ;
32606 int arg4 = (int) true ;
32607 PyObject * obj0 = 0 ;
32608 PyObject * obj1 = 0 ;
32609 PyObject * obj2 = 0 ;
32610 PyObject * obj3 = 0 ;
32611 char *kwnames[] = {
32612 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32613 };
32614
32615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32617 if (SWIG_arg_fail(1)) SWIG_fail;
32618 arg2 = obj1;
32619 arg3 = obj2;
32620 if (obj3) {
32621 {
32622 arg4 = (int)(SWIG_As_int(obj3));
32623 if (SWIG_arg_fail(4)) SWIG_fail;
32624 }
32625 }
32626 {
32627 PyThreadState* __tstate = wxPyBeginAllowThreads();
32628 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32629
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 Py_INCREF(Py_None); resultobj = Py_None;
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32641 PyObject *obj;
32642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32643 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32644 Py_INCREF(obj);
32645 return Py_BuildValue((char *)"");
32646 }
32647 static int _wrap_DefaultValidator_set(PyObject *) {
32648 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32649 return 1;
32650 }
32651
32652
32653 static PyObject *_wrap_DefaultValidator_get(void) {
32654 PyObject *pyobj;
32655
32656 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32657 return pyobj;
32658 }
32659
32660
32661 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj;
32663 wxString const &arg1_defvalue = wxPyEmptyString ;
32664 wxString *arg1 = (wxString *) &arg1_defvalue ;
32665 long arg2 = (long) 0 ;
32666 wxMenu *result;
32667 bool temp1 = false ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 char *kwnames[] = {
32671 (char *) "title",(char *) "style", NULL
32672 };
32673
32674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32675 if (obj0) {
32676 {
32677 arg1 = wxString_in_helper(obj0);
32678 if (arg1 == NULL) SWIG_fail;
32679 temp1 = true;
32680 }
32681 }
32682 if (obj1) {
32683 {
32684 arg2 = (long)(SWIG_As_long(obj1));
32685 if (SWIG_arg_fail(2)) SWIG_fail;
32686 }
32687 }
32688 {
32689 if (!wxPyCheckForApp()) SWIG_fail;
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32692
32693 wxPyEndAllowThreads(__tstate);
32694 if (PyErr_Occurred()) SWIG_fail;
32695 }
32696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32697 {
32698 if (temp1)
32699 delete arg1;
32700 }
32701 return resultobj;
32702 fail:
32703 {
32704 if (temp1)
32705 delete arg1;
32706 }
32707 return NULL;
32708 }
32709
32710
32711 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32712 PyObject *resultobj;
32713 wxMenu *arg1 = (wxMenu *) 0 ;
32714 int arg2 ;
32715 wxString *arg3 = 0 ;
32716 wxString const &arg4_defvalue = wxPyEmptyString ;
32717 wxString *arg4 = (wxString *) &arg4_defvalue ;
32718 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32719 wxMenuItem *result;
32720 bool temp3 = false ;
32721 bool temp4 = false ;
32722 PyObject * obj0 = 0 ;
32723 PyObject * obj1 = 0 ;
32724 PyObject * obj2 = 0 ;
32725 PyObject * obj3 = 0 ;
32726 PyObject * obj4 = 0 ;
32727 char *kwnames[] = {
32728 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32729 };
32730
32731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32733 if (SWIG_arg_fail(1)) SWIG_fail;
32734 {
32735 arg2 = (int)(SWIG_As_int(obj1));
32736 if (SWIG_arg_fail(2)) SWIG_fail;
32737 }
32738 {
32739 arg3 = wxString_in_helper(obj2);
32740 if (arg3 == NULL) SWIG_fail;
32741 temp3 = true;
32742 }
32743 if (obj3) {
32744 {
32745 arg4 = wxString_in_helper(obj3);
32746 if (arg4 == NULL) SWIG_fail;
32747 temp4 = true;
32748 }
32749 }
32750 if (obj4) {
32751 {
32752 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32753 if (SWIG_arg_fail(5)) SWIG_fail;
32754 }
32755 }
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32759
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 {
32764 resultobj = wxPyMake_wxObject(result, 0);
32765 }
32766 {
32767 if (temp3)
32768 delete arg3;
32769 }
32770 {
32771 if (temp4)
32772 delete arg4;
32773 }
32774 return resultobj;
32775 fail:
32776 {
32777 if (temp3)
32778 delete arg3;
32779 }
32780 {
32781 if (temp4)
32782 delete arg4;
32783 }
32784 return NULL;
32785 }
32786
32787
32788 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj;
32790 wxMenu *arg1 = (wxMenu *) 0 ;
32791 wxMenuItem *result;
32792 PyObject * obj0 = 0 ;
32793 char *kwnames[] = {
32794 (char *) "self", NULL
32795 };
32796
32797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32799 if (SWIG_arg_fail(1)) SWIG_fail;
32800 {
32801 PyThreadState* __tstate = wxPyBeginAllowThreads();
32802 result = (wxMenuItem *)(arg1)->AppendSeparator();
32803
32804 wxPyEndAllowThreads(__tstate);
32805 if (PyErr_Occurred()) SWIG_fail;
32806 }
32807 {
32808 resultobj = wxPyMake_wxObject(result, 0);
32809 }
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32817 PyObject *resultobj;
32818 wxMenu *arg1 = (wxMenu *) 0 ;
32819 int arg2 ;
32820 wxString *arg3 = 0 ;
32821 wxString const &arg4_defvalue = wxPyEmptyString ;
32822 wxString *arg4 = (wxString *) &arg4_defvalue ;
32823 wxMenuItem *result;
32824 bool temp3 = false ;
32825 bool temp4 = false ;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 PyObject * obj2 = 0 ;
32829 PyObject * obj3 = 0 ;
32830 char *kwnames[] = {
32831 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32832 };
32833
32834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32836 if (SWIG_arg_fail(1)) SWIG_fail;
32837 {
32838 arg2 = (int)(SWIG_As_int(obj1));
32839 if (SWIG_arg_fail(2)) SWIG_fail;
32840 }
32841 {
32842 arg3 = wxString_in_helper(obj2);
32843 if (arg3 == NULL) SWIG_fail;
32844 temp3 = true;
32845 }
32846 if (obj3) {
32847 {
32848 arg4 = wxString_in_helper(obj3);
32849 if (arg4 == NULL) SWIG_fail;
32850 temp4 = true;
32851 }
32852 }
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32856
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 {
32861 resultobj = wxPyMake_wxObject(result, 0);
32862 }
32863 {
32864 if (temp3)
32865 delete arg3;
32866 }
32867 {
32868 if (temp4)
32869 delete arg4;
32870 }
32871 return resultobj;
32872 fail:
32873 {
32874 if (temp3)
32875 delete arg3;
32876 }
32877 {
32878 if (temp4)
32879 delete arg4;
32880 }
32881 return NULL;
32882 }
32883
32884
32885 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32886 PyObject *resultobj;
32887 wxMenu *arg1 = (wxMenu *) 0 ;
32888 int arg2 ;
32889 wxString *arg3 = 0 ;
32890 wxString const &arg4_defvalue = wxPyEmptyString ;
32891 wxString *arg4 = (wxString *) &arg4_defvalue ;
32892 wxMenuItem *result;
32893 bool temp3 = false ;
32894 bool temp4 = false ;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 PyObject * obj2 = 0 ;
32898 PyObject * obj3 = 0 ;
32899 char *kwnames[] = {
32900 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32901 };
32902
32903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32905 if (SWIG_arg_fail(1)) SWIG_fail;
32906 {
32907 arg2 = (int)(SWIG_As_int(obj1));
32908 if (SWIG_arg_fail(2)) SWIG_fail;
32909 }
32910 {
32911 arg3 = wxString_in_helper(obj2);
32912 if (arg3 == NULL) SWIG_fail;
32913 temp3 = true;
32914 }
32915 if (obj3) {
32916 {
32917 arg4 = wxString_in_helper(obj3);
32918 if (arg4 == NULL) SWIG_fail;
32919 temp4 = true;
32920 }
32921 }
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32925
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 {
32930 resultobj = wxPyMake_wxObject(result, 0);
32931 }
32932 {
32933 if (temp3)
32934 delete arg3;
32935 }
32936 {
32937 if (temp4)
32938 delete arg4;
32939 }
32940 return resultobj;
32941 fail:
32942 {
32943 if (temp3)
32944 delete arg3;
32945 }
32946 {
32947 if (temp4)
32948 delete arg4;
32949 }
32950 return NULL;
32951 }
32952
32953
32954 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32955 PyObject *resultobj;
32956 wxMenu *arg1 = (wxMenu *) 0 ;
32957 int arg2 ;
32958 wxString *arg3 = 0 ;
32959 wxMenu *arg4 = (wxMenu *) 0 ;
32960 wxString const &arg5_defvalue = wxPyEmptyString ;
32961 wxString *arg5 = (wxString *) &arg5_defvalue ;
32962 wxMenuItem *result;
32963 bool temp3 = false ;
32964 bool temp5 = false ;
32965 PyObject * obj0 = 0 ;
32966 PyObject * obj1 = 0 ;
32967 PyObject * obj2 = 0 ;
32968 PyObject * obj3 = 0 ;
32969 PyObject * obj4 = 0 ;
32970 char *kwnames[] = {
32971 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32972 };
32973
32974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32976 if (SWIG_arg_fail(1)) SWIG_fail;
32977 {
32978 arg2 = (int)(SWIG_As_int(obj1));
32979 if (SWIG_arg_fail(2)) SWIG_fail;
32980 }
32981 {
32982 arg3 = wxString_in_helper(obj2);
32983 if (arg3 == NULL) SWIG_fail;
32984 temp3 = true;
32985 }
32986 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32987 if (SWIG_arg_fail(4)) SWIG_fail;
32988 if (obj4) {
32989 {
32990 arg5 = wxString_in_helper(obj4);
32991 if (arg5 == NULL) SWIG_fail;
32992 temp5 = true;
32993 }
32994 }
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32998
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = wxPyMake_wxObject(result, 0);
33004 }
33005 {
33006 if (temp3)
33007 delete arg3;
33008 }
33009 {
33010 if (temp5)
33011 delete arg5;
33012 }
33013 return resultobj;
33014 fail:
33015 {
33016 if (temp3)
33017 delete arg3;
33018 }
33019 {
33020 if (temp5)
33021 delete arg5;
33022 }
33023 return NULL;
33024 }
33025
33026
33027 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj;
33029 wxMenu *arg1 = (wxMenu *) 0 ;
33030 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33031 wxMenuItem *result;
33032 PyObject * obj0 = 0 ;
33033 PyObject * obj1 = 0 ;
33034 char *kwnames[] = {
33035 (char *) "self",(char *) "item", NULL
33036 };
33037
33038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33040 if (SWIG_arg_fail(1)) SWIG_fail;
33041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33042 if (SWIG_arg_fail(2)) SWIG_fail;
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 result = (wxMenuItem *)(arg1)->Append(arg2);
33046
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 {
33051 resultobj = wxPyMake_wxObject(result, 0);
33052 }
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj;
33061 wxMenu *arg1 = (wxMenu *) 0 ;
33062 PyObject * obj0 = 0 ;
33063 char *kwnames[] = {
33064 (char *) "self", NULL
33065 };
33066
33067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33069 if (SWIG_arg_fail(1)) SWIG_fail;
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 (arg1)->Break();
33073
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 Py_INCREF(Py_None); resultobj = Py_None;
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj;
33086 wxMenu *arg1 = (wxMenu *) 0 ;
33087 size_t arg2 ;
33088 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33089 wxMenuItem *result;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 PyObject * obj2 = 0 ;
33093 char *kwnames[] = {
33094 (char *) "self",(char *) "pos",(char *) "item", NULL
33095 };
33096
33097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33099 if (SWIG_arg_fail(1)) SWIG_fail;
33100 {
33101 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33102 if (SWIG_arg_fail(2)) SWIG_fail;
33103 }
33104 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33105 if (SWIG_arg_fail(3)) SWIG_fail;
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33109
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = wxPyMake_wxObject(result, 0);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33123 PyObject *resultobj;
33124 wxMenu *arg1 = (wxMenu *) 0 ;
33125 size_t arg2 ;
33126 int arg3 ;
33127 wxString *arg4 = 0 ;
33128 wxString const &arg5_defvalue = wxPyEmptyString ;
33129 wxString *arg5 = (wxString *) &arg5_defvalue ;
33130 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33131 wxMenuItem *result;
33132 bool temp4 = false ;
33133 bool temp5 = false ;
33134 PyObject * obj0 = 0 ;
33135 PyObject * obj1 = 0 ;
33136 PyObject * obj2 = 0 ;
33137 PyObject * obj3 = 0 ;
33138 PyObject * obj4 = 0 ;
33139 PyObject * obj5 = 0 ;
33140 char *kwnames[] = {
33141 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33142 };
33143
33144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33146 if (SWIG_arg_fail(1)) SWIG_fail;
33147 {
33148 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33149 if (SWIG_arg_fail(2)) SWIG_fail;
33150 }
33151 {
33152 arg3 = (int)(SWIG_As_int(obj2));
33153 if (SWIG_arg_fail(3)) SWIG_fail;
33154 }
33155 {
33156 arg4 = wxString_in_helper(obj3);
33157 if (arg4 == NULL) SWIG_fail;
33158 temp4 = true;
33159 }
33160 if (obj4) {
33161 {
33162 arg5 = wxString_in_helper(obj4);
33163 if (arg5 == NULL) SWIG_fail;
33164 temp5 = true;
33165 }
33166 }
33167 if (obj5) {
33168 {
33169 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33170 if (SWIG_arg_fail(6)) SWIG_fail;
33171 }
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33176
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 {
33181 resultobj = wxPyMake_wxObject(result, 0);
33182 }
33183 {
33184 if (temp4)
33185 delete arg4;
33186 }
33187 {
33188 if (temp5)
33189 delete arg5;
33190 }
33191 return resultobj;
33192 fail:
33193 {
33194 if (temp4)
33195 delete arg4;
33196 }
33197 {
33198 if (temp5)
33199 delete arg5;
33200 }
33201 return NULL;
33202 }
33203
33204
33205 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj;
33207 wxMenu *arg1 = (wxMenu *) 0 ;
33208 size_t arg2 ;
33209 wxMenuItem *result;
33210 PyObject * obj0 = 0 ;
33211 PyObject * obj1 = 0 ;
33212 char *kwnames[] = {
33213 (char *) "self",(char *) "pos", NULL
33214 };
33215
33216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33218 if (SWIG_arg_fail(1)) SWIG_fail;
33219 {
33220 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33221 if (SWIG_arg_fail(2)) SWIG_fail;
33222 }
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33226
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 {
33231 resultobj = wxPyMake_wxObject(result, 0);
33232 }
33233 return resultobj;
33234 fail:
33235 return NULL;
33236 }
33237
33238
33239 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj;
33241 wxMenu *arg1 = (wxMenu *) 0 ;
33242 size_t arg2 ;
33243 int arg3 ;
33244 wxString *arg4 = 0 ;
33245 wxString const &arg5_defvalue = wxPyEmptyString ;
33246 wxString *arg5 = (wxString *) &arg5_defvalue ;
33247 wxMenuItem *result;
33248 bool temp4 = false ;
33249 bool temp5 = false ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 PyObject * obj2 = 0 ;
33253 PyObject * obj3 = 0 ;
33254 PyObject * obj4 = 0 ;
33255 char *kwnames[] = {
33256 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33257 };
33258
33259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33261 if (SWIG_arg_fail(1)) SWIG_fail;
33262 {
33263 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33264 if (SWIG_arg_fail(2)) SWIG_fail;
33265 }
33266 {
33267 arg3 = (int)(SWIG_As_int(obj2));
33268 if (SWIG_arg_fail(3)) SWIG_fail;
33269 }
33270 {
33271 arg4 = wxString_in_helper(obj3);
33272 if (arg4 == NULL) SWIG_fail;
33273 temp4 = true;
33274 }
33275 if (obj4) {
33276 {
33277 arg5 = wxString_in_helper(obj4);
33278 if (arg5 == NULL) SWIG_fail;
33279 temp5 = true;
33280 }
33281 }
33282 {
33283 PyThreadState* __tstate = wxPyBeginAllowThreads();
33284 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33285
33286 wxPyEndAllowThreads(__tstate);
33287 if (PyErr_Occurred()) SWIG_fail;
33288 }
33289 {
33290 resultobj = wxPyMake_wxObject(result, 0);
33291 }
33292 {
33293 if (temp4)
33294 delete arg4;
33295 }
33296 {
33297 if (temp5)
33298 delete arg5;
33299 }
33300 return resultobj;
33301 fail:
33302 {
33303 if (temp4)
33304 delete arg4;
33305 }
33306 {
33307 if (temp5)
33308 delete arg5;
33309 }
33310 return NULL;
33311 }
33312
33313
33314 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33315 PyObject *resultobj;
33316 wxMenu *arg1 = (wxMenu *) 0 ;
33317 size_t arg2 ;
33318 int arg3 ;
33319 wxString *arg4 = 0 ;
33320 wxString const &arg5_defvalue = wxPyEmptyString ;
33321 wxString *arg5 = (wxString *) &arg5_defvalue ;
33322 wxMenuItem *result;
33323 bool temp4 = false ;
33324 bool temp5 = false ;
33325 PyObject * obj0 = 0 ;
33326 PyObject * obj1 = 0 ;
33327 PyObject * obj2 = 0 ;
33328 PyObject * obj3 = 0 ;
33329 PyObject * obj4 = 0 ;
33330 char *kwnames[] = {
33331 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33332 };
33333
33334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33336 if (SWIG_arg_fail(1)) SWIG_fail;
33337 {
33338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33339 if (SWIG_arg_fail(2)) SWIG_fail;
33340 }
33341 {
33342 arg3 = (int)(SWIG_As_int(obj2));
33343 if (SWIG_arg_fail(3)) SWIG_fail;
33344 }
33345 {
33346 arg4 = wxString_in_helper(obj3);
33347 if (arg4 == NULL) SWIG_fail;
33348 temp4 = true;
33349 }
33350 if (obj4) {
33351 {
33352 arg5 = wxString_in_helper(obj4);
33353 if (arg5 == NULL) SWIG_fail;
33354 temp5 = true;
33355 }
33356 }
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33360
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 {
33365 resultobj = wxPyMake_wxObject(result, 0);
33366 }
33367 {
33368 if (temp4)
33369 delete arg4;
33370 }
33371 {
33372 if (temp5)
33373 delete arg5;
33374 }
33375 return resultobj;
33376 fail:
33377 {
33378 if (temp4)
33379 delete arg4;
33380 }
33381 {
33382 if (temp5)
33383 delete arg5;
33384 }
33385 return NULL;
33386 }
33387
33388
33389 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33390 PyObject *resultobj;
33391 wxMenu *arg1 = (wxMenu *) 0 ;
33392 size_t arg2 ;
33393 int arg3 ;
33394 wxString *arg4 = 0 ;
33395 wxMenu *arg5 = (wxMenu *) 0 ;
33396 wxString const &arg6_defvalue = wxPyEmptyString ;
33397 wxString *arg6 = (wxString *) &arg6_defvalue ;
33398 wxMenuItem *result;
33399 bool temp4 = false ;
33400 bool temp6 = false ;
33401 PyObject * obj0 = 0 ;
33402 PyObject * obj1 = 0 ;
33403 PyObject * obj2 = 0 ;
33404 PyObject * obj3 = 0 ;
33405 PyObject * obj4 = 0 ;
33406 PyObject * obj5 = 0 ;
33407 char *kwnames[] = {
33408 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33409 };
33410
33411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33413 if (SWIG_arg_fail(1)) SWIG_fail;
33414 {
33415 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33416 if (SWIG_arg_fail(2)) SWIG_fail;
33417 }
33418 {
33419 arg3 = (int)(SWIG_As_int(obj2));
33420 if (SWIG_arg_fail(3)) SWIG_fail;
33421 }
33422 {
33423 arg4 = wxString_in_helper(obj3);
33424 if (arg4 == NULL) SWIG_fail;
33425 temp4 = true;
33426 }
33427 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(5)) SWIG_fail;
33429 if (obj5) {
33430 {
33431 arg6 = wxString_in_helper(obj5);
33432 if (arg6 == NULL) SWIG_fail;
33433 temp6 = true;
33434 }
33435 }
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33439
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 {
33444 resultobj = wxPyMake_wxObject(result, 0);
33445 }
33446 {
33447 if (temp4)
33448 delete arg4;
33449 }
33450 {
33451 if (temp6)
33452 delete arg6;
33453 }
33454 return resultobj;
33455 fail:
33456 {
33457 if (temp4)
33458 delete arg4;
33459 }
33460 {
33461 if (temp6)
33462 delete arg6;
33463 }
33464 return NULL;
33465 }
33466
33467
33468 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33469 PyObject *resultobj;
33470 wxMenu *arg1 = (wxMenu *) 0 ;
33471 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33472 wxMenuItem *result;
33473 PyObject * obj0 = 0 ;
33474 PyObject * obj1 = 0 ;
33475 char *kwnames[] = {
33476 (char *) "self",(char *) "item", NULL
33477 };
33478
33479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33481 if (SWIG_arg_fail(1)) SWIG_fail;
33482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33483 if (SWIG_arg_fail(2)) SWIG_fail;
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33487
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 {
33492 resultobj = wxPyMake_wxObject(result, 0);
33493 }
33494 return resultobj;
33495 fail:
33496 return NULL;
33497 }
33498
33499
33500 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33501 PyObject *resultobj;
33502 wxMenu *arg1 = (wxMenu *) 0 ;
33503 int arg2 ;
33504 wxString *arg3 = 0 ;
33505 wxString const &arg4_defvalue = wxPyEmptyString ;
33506 wxString *arg4 = (wxString *) &arg4_defvalue ;
33507 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33508 wxMenuItem *result;
33509 bool temp3 = false ;
33510 bool temp4 = false ;
33511 PyObject * obj0 = 0 ;
33512 PyObject * obj1 = 0 ;
33513 PyObject * obj2 = 0 ;
33514 PyObject * obj3 = 0 ;
33515 PyObject * obj4 = 0 ;
33516 char *kwnames[] = {
33517 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33518 };
33519
33520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33522 if (SWIG_arg_fail(1)) SWIG_fail;
33523 {
33524 arg2 = (int)(SWIG_As_int(obj1));
33525 if (SWIG_arg_fail(2)) SWIG_fail;
33526 }
33527 {
33528 arg3 = wxString_in_helper(obj2);
33529 if (arg3 == NULL) SWIG_fail;
33530 temp3 = true;
33531 }
33532 if (obj3) {
33533 {
33534 arg4 = wxString_in_helper(obj3);
33535 if (arg4 == NULL) SWIG_fail;
33536 temp4 = true;
33537 }
33538 }
33539 if (obj4) {
33540 {
33541 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33542 if (SWIG_arg_fail(5)) SWIG_fail;
33543 }
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33548
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 {
33553 resultobj = wxPyMake_wxObject(result, 0);
33554 }
33555 {
33556 if (temp3)
33557 delete arg3;
33558 }
33559 {
33560 if (temp4)
33561 delete arg4;
33562 }
33563 return resultobj;
33564 fail:
33565 {
33566 if (temp3)
33567 delete arg3;
33568 }
33569 {
33570 if (temp4)
33571 delete arg4;
33572 }
33573 return NULL;
33574 }
33575
33576
33577 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj;
33579 wxMenu *arg1 = (wxMenu *) 0 ;
33580 wxMenuItem *result;
33581 PyObject * obj0 = 0 ;
33582 char *kwnames[] = {
33583 (char *) "self", NULL
33584 };
33585
33586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33588 if (SWIG_arg_fail(1)) SWIG_fail;
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (wxMenuItem *)(arg1)->PrependSeparator();
33592
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 {
33597 resultobj = wxPyMake_wxObject(result, 0);
33598 }
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj;
33607 wxMenu *arg1 = (wxMenu *) 0 ;
33608 int arg2 ;
33609 wxString *arg3 = 0 ;
33610 wxString const &arg4_defvalue = wxPyEmptyString ;
33611 wxString *arg4 = (wxString *) &arg4_defvalue ;
33612 wxMenuItem *result;
33613 bool temp3 = false ;
33614 bool temp4 = false ;
33615 PyObject * obj0 = 0 ;
33616 PyObject * obj1 = 0 ;
33617 PyObject * obj2 = 0 ;
33618 PyObject * obj3 = 0 ;
33619 char *kwnames[] = {
33620 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33621 };
33622
33623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33625 if (SWIG_arg_fail(1)) SWIG_fail;
33626 {
33627 arg2 = (int)(SWIG_As_int(obj1));
33628 if (SWIG_arg_fail(2)) SWIG_fail;
33629 }
33630 {
33631 arg3 = wxString_in_helper(obj2);
33632 if (arg3 == NULL) SWIG_fail;
33633 temp3 = true;
33634 }
33635 if (obj3) {
33636 {
33637 arg4 = wxString_in_helper(obj3);
33638 if (arg4 == NULL) SWIG_fail;
33639 temp4 = true;
33640 }
33641 }
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33645
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = wxPyMake_wxObject(result, 0);
33651 }
33652 {
33653 if (temp3)
33654 delete arg3;
33655 }
33656 {
33657 if (temp4)
33658 delete arg4;
33659 }
33660 return resultobj;
33661 fail:
33662 {
33663 if (temp3)
33664 delete arg3;
33665 }
33666 {
33667 if (temp4)
33668 delete arg4;
33669 }
33670 return NULL;
33671 }
33672
33673
33674 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj;
33676 wxMenu *arg1 = (wxMenu *) 0 ;
33677 int arg2 ;
33678 wxString *arg3 = 0 ;
33679 wxString const &arg4_defvalue = wxPyEmptyString ;
33680 wxString *arg4 = (wxString *) &arg4_defvalue ;
33681 wxMenuItem *result;
33682 bool temp3 = false ;
33683 bool temp4 = false ;
33684 PyObject * obj0 = 0 ;
33685 PyObject * obj1 = 0 ;
33686 PyObject * obj2 = 0 ;
33687 PyObject * obj3 = 0 ;
33688 char *kwnames[] = {
33689 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33690 };
33691
33692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33694 if (SWIG_arg_fail(1)) SWIG_fail;
33695 {
33696 arg2 = (int)(SWIG_As_int(obj1));
33697 if (SWIG_arg_fail(2)) SWIG_fail;
33698 }
33699 {
33700 arg3 = wxString_in_helper(obj2);
33701 if (arg3 == NULL) SWIG_fail;
33702 temp3 = true;
33703 }
33704 if (obj3) {
33705 {
33706 arg4 = wxString_in_helper(obj3);
33707 if (arg4 == NULL) SWIG_fail;
33708 temp4 = true;
33709 }
33710 }
33711 {
33712 PyThreadState* __tstate = wxPyBeginAllowThreads();
33713 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33714
33715 wxPyEndAllowThreads(__tstate);
33716 if (PyErr_Occurred()) SWIG_fail;
33717 }
33718 {
33719 resultobj = wxPyMake_wxObject(result, 0);
33720 }
33721 {
33722 if (temp3)
33723 delete arg3;
33724 }
33725 {
33726 if (temp4)
33727 delete arg4;
33728 }
33729 return resultobj;
33730 fail:
33731 {
33732 if (temp3)
33733 delete arg3;
33734 }
33735 {
33736 if (temp4)
33737 delete arg4;
33738 }
33739 return NULL;
33740 }
33741
33742
33743 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33744 PyObject *resultobj;
33745 wxMenu *arg1 = (wxMenu *) 0 ;
33746 int arg2 ;
33747 wxString *arg3 = 0 ;
33748 wxMenu *arg4 = (wxMenu *) 0 ;
33749 wxString const &arg5_defvalue = wxPyEmptyString ;
33750 wxString *arg5 = (wxString *) &arg5_defvalue ;
33751 wxMenuItem *result;
33752 bool temp3 = false ;
33753 bool temp5 = false ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 PyObject * obj2 = 0 ;
33757 PyObject * obj3 = 0 ;
33758 PyObject * obj4 = 0 ;
33759 char *kwnames[] = {
33760 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33761 };
33762
33763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33765 if (SWIG_arg_fail(1)) SWIG_fail;
33766 {
33767 arg2 = (int)(SWIG_As_int(obj1));
33768 if (SWIG_arg_fail(2)) SWIG_fail;
33769 }
33770 {
33771 arg3 = wxString_in_helper(obj2);
33772 if (arg3 == NULL) SWIG_fail;
33773 temp3 = true;
33774 }
33775 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33776 if (SWIG_arg_fail(4)) SWIG_fail;
33777 if (obj4) {
33778 {
33779 arg5 = wxString_in_helper(obj4);
33780 if (arg5 == NULL) SWIG_fail;
33781 temp5 = true;
33782 }
33783 }
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33787
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 {
33792 resultobj = wxPyMake_wxObject(result, 0);
33793 }
33794 {
33795 if (temp3)
33796 delete arg3;
33797 }
33798 {
33799 if (temp5)
33800 delete arg5;
33801 }
33802 return resultobj;
33803 fail:
33804 {
33805 if (temp3)
33806 delete arg3;
33807 }
33808 {
33809 if (temp5)
33810 delete arg5;
33811 }
33812 return NULL;
33813 }
33814
33815
33816 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj;
33818 wxMenu *arg1 = (wxMenu *) 0 ;
33819 int arg2 ;
33820 wxMenuItem *result;
33821 PyObject * obj0 = 0 ;
33822 PyObject * obj1 = 0 ;
33823 char *kwnames[] = {
33824 (char *) "self",(char *) "id", NULL
33825 };
33826
33827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33829 if (SWIG_arg_fail(1)) SWIG_fail;
33830 {
33831 arg2 = (int)(SWIG_As_int(obj1));
33832 if (SWIG_arg_fail(2)) SWIG_fail;
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 result = (wxMenuItem *)(arg1)->Remove(arg2);
33837
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 {
33842 resultobj = wxPyMake_wxObject(result, 0);
33843 }
33844 return resultobj;
33845 fail:
33846 return NULL;
33847 }
33848
33849
33850 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33851 PyObject *resultobj;
33852 wxMenu *arg1 = (wxMenu *) 0 ;
33853 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33854 wxMenuItem *result;
33855 PyObject * obj0 = 0 ;
33856 PyObject * obj1 = 0 ;
33857 char *kwnames[] = {
33858 (char *) "self",(char *) "item", NULL
33859 };
33860
33861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33863 if (SWIG_arg_fail(1)) SWIG_fail;
33864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33865 if (SWIG_arg_fail(2)) SWIG_fail;
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_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 int arg2 ;
33886 bool result;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char *kwnames[] = {
33890 (char *) "self",(char *) "id", NULL
33891 };
33892
33893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",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 {
33897 arg2 = (int)(SWIG_As_int(obj1));
33898 if (SWIG_arg_fail(2)) SWIG_fail;
33899 }
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 result = (bool)(arg1)->Delete(arg2);
33903
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 {
33908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj;
33918 wxMenu *arg1 = (wxMenu *) 0 ;
33919 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33920 bool result;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char *kwnames[] = {
33924 (char *) "self",(char *) "item", NULL
33925 };
33926
33927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33929 if (SWIG_arg_fail(1)) SWIG_fail;
33930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(2)) SWIG_fail;
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_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj;
33950 wxMenu *arg1 = (wxMenu *) 0 ;
33951 PyObject * obj0 = 0 ;
33952 char *kwnames[] = {
33953 (char *) "self", NULL
33954 };
33955
33956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33958 if (SWIG_arg_fail(1)) SWIG_fail;
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 wxMenu_Destroy(arg1);
33962
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 Py_INCREF(Py_None); resultobj = Py_None;
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj;
33975 wxMenu *arg1 = (wxMenu *) 0 ;
33976 int arg2 ;
33977 bool result;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 char *kwnames[] = {
33981 (char *) "self",(char *) "id", NULL
33982 };
33983
33984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33986 if (SWIG_arg_fail(1)) SWIG_fail;
33987 {
33988 arg2 = (int)(SWIG_As_int(obj1));
33989 if (SWIG_arg_fail(2)) SWIG_fail;
33990 }
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = (bool)(arg1)->Destroy(arg2);
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 {
33999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34000 }
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj;
34009 wxMenu *arg1 = (wxMenu *) 0 ;
34010 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34011 bool result;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 char *kwnames[] = {
34015 (char *) "self",(char *) "item", NULL
34016 };
34017
34018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34020 if (SWIG_arg_fail(1)) SWIG_fail;
34021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34022 if (SWIG_arg_fail(2)) SWIG_fail;
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_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 size_t result;
34043 PyObject * obj0 = 0 ;
34044 char *kwnames[] = {
34045 (char *) "self", NULL
34046 };
34047
34048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34050 if (SWIG_arg_fail(1)) SWIG_fail;
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34054
34055 wxPyEndAllowThreads(__tstate);
34056 if (PyErr_Occurred()) SWIG_fail;
34057 }
34058 {
34059 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34060 }
34061 return resultobj;
34062 fail:
34063 return NULL;
34064 }
34065
34066
34067 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34068 PyObject *resultobj;
34069 wxMenu *arg1 = (wxMenu *) 0 ;
34070 PyObject *result;
34071 PyObject * obj0 = 0 ;
34072 char *kwnames[] = {
34073 (char *) "self", NULL
34074 };
34075
34076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34078 if (SWIG_arg_fail(1)) SWIG_fail;
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34082
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = result;
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj;
34095 wxMenu *arg1 = (wxMenu *) 0 ;
34096 wxString *arg2 = 0 ;
34097 int result;
34098 bool temp2 = false ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char *kwnames[] = {
34102 (char *) "self",(char *) "item", NULL
34103 };
34104
34105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34107 if (SWIG_arg_fail(1)) SWIG_fail;
34108 {
34109 arg2 = wxString_in_helper(obj1);
34110 if (arg2 == NULL) SWIG_fail;
34111 temp2 = true;
34112 }
34113 {
34114 PyThreadState* __tstate = wxPyBeginAllowThreads();
34115 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34116
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 {
34121 resultobj = SWIG_From_int((int)(result));
34122 }
34123 {
34124 if (temp2)
34125 delete arg2;
34126 }
34127 return resultobj;
34128 fail:
34129 {
34130 if (temp2)
34131 delete arg2;
34132 }
34133 return NULL;
34134 }
34135
34136
34137 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34138 PyObject *resultobj;
34139 wxMenu *arg1 = (wxMenu *) 0 ;
34140 int arg2 ;
34141 wxMenuItem *result;
34142 PyObject * obj0 = 0 ;
34143 PyObject * obj1 = 0 ;
34144 char *kwnames[] = {
34145 (char *) "self",(char *) "id", NULL
34146 };
34147
34148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34150 if (SWIG_arg_fail(1)) SWIG_fail;
34151 {
34152 arg2 = (int)(SWIG_As_int(obj1));
34153 if (SWIG_arg_fail(2)) SWIG_fail;
34154 }
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34158
34159 wxPyEndAllowThreads(__tstate);
34160 if (PyErr_Occurred()) SWIG_fail;
34161 }
34162 {
34163 resultobj = wxPyMake_wxObject(result, 0);
34164 }
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj;
34173 wxMenu *arg1 = (wxMenu *) 0 ;
34174 size_t arg2 ;
34175 wxMenuItem *result;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 char *kwnames[] = {
34179 (char *) "self",(char *) "position", NULL
34180 };
34181
34182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34184 if (SWIG_arg_fail(1)) SWIG_fail;
34185 {
34186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34187 if (SWIG_arg_fail(2)) SWIG_fail;
34188 }
34189 {
34190 PyThreadState* __tstate = wxPyBeginAllowThreads();
34191 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34192
34193 wxPyEndAllowThreads(__tstate);
34194 if (PyErr_Occurred()) SWIG_fail;
34195 }
34196 {
34197 resultobj = wxPyMake_wxObject(result, 0);
34198 }
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj;
34207 wxMenu *arg1 = (wxMenu *) 0 ;
34208 int arg2 ;
34209 bool arg3 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 PyObject * obj2 = 0 ;
34213 char *kwnames[] = {
34214 (char *) "self",(char *) "id",(char *) "enable", NULL
34215 };
34216
34217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34219 if (SWIG_arg_fail(1)) SWIG_fail;
34220 {
34221 arg2 = (int)(SWIG_As_int(obj1));
34222 if (SWIG_arg_fail(2)) SWIG_fail;
34223 }
34224 {
34225 arg3 = (bool)(SWIG_As_bool(obj2));
34226 if (SWIG_arg_fail(3)) SWIG_fail;
34227 }
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->Enable(arg2,arg3);
34231
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 Py_INCREF(Py_None); resultobj = Py_None;
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34243 PyObject *resultobj;
34244 wxMenu *arg1 = (wxMenu *) 0 ;
34245 int arg2 ;
34246 bool result;
34247 PyObject * obj0 = 0 ;
34248 PyObject * obj1 = 0 ;
34249 char *kwnames[] = {
34250 (char *) "self",(char *) "id", NULL
34251 };
34252
34253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34255 if (SWIG_arg_fail(1)) SWIG_fail;
34256 {
34257 arg2 = (int)(SWIG_As_int(obj1));
34258 if (SWIG_arg_fail(2)) SWIG_fail;
34259 }
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34263
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 {
34268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34269 }
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34277 PyObject *resultobj;
34278 wxMenu *arg1 = (wxMenu *) 0 ;
34279 int arg2 ;
34280 bool arg3 ;
34281 PyObject * obj0 = 0 ;
34282 PyObject * obj1 = 0 ;
34283 PyObject * obj2 = 0 ;
34284 char *kwnames[] = {
34285 (char *) "self",(char *) "id",(char *) "check", NULL
34286 };
34287
34288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34290 if (SWIG_arg_fail(1)) SWIG_fail;
34291 {
34292 arg2 = (int)(SWIG_As_int(obj1));
34293 if (SWIG_arg_fail(2)) SWIG_fail;
34294 }
34295 {
34296 arg3 = (bool)(SWIG_As_bool(obj2));
34297 if (SWIG_arg_fail(3)) SWIG_fail;
34298 }
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 (arg1)->Check(arg2,arg3);
34302
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 Py_INCREF(Py_None); resultobj = Py_None;
34307 return resultobj;
34308 fail:
34309 return NULL;
34310 }
34311
34312
34313 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34314 PyObject *resultobj;
34315 wxMenu *arg1 = (wxMenu *) 0 ;
34316 int arg2 ;
34317 bool result;
34318 PyObject * obj0 = 0 ;
34319 PyObject * obj1 = 0 ;
34320 char *kwnames[] = {
34321 (char *) "self",(char *) "id", NULL
34322 };
34323
34324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34326 if (SWIG_arg_fail(1)) SWIG_fail;
34327 {
34328 arg2 = (int)(SWIG_As_int(obj1));
34329 if (SWIG_arg_fail(2)) SWIG_fail;
34330 }
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34334
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 {
34339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34340 }
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj;
34349 wxMenu *arg1 = (wxMenu *) 0 ;
34350 int arg2 ;
34351 wxString *arg3 = 0 ;
34352 bool temp3 = false ;
34353 PyObject * obj0 = 0 ;
34354 PyObject * obj1 = 0 ;
34355 PyObject * obj2 = 0 ;
34356 char *kwnames[] = {
34357 (char *) "self",(char *) "id",(char *) "label", NULL
34358 };
34359
34360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34362 if (SWIG_arg_fail(1)) SWIG_fail;
34363 {
34364 arg2 = (int)(SWIG_As_int(obj1));
34365 if (SWIG_arg_fail(2)) SWIG_fail;
34366 }
34367 {
34368 arg3 = wxString_in_helper(obj2);
34369 if (arg3 == NULL) SWIG_fail;
34370 temp3 = true;
34371 }
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34375
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 Py_INCREF(Py_None); resultobj = Py_None;
34380 {
34381 if (temp3)
34382 delete arg3;
34383 }
34384 return resultobj;
34385 fail:
34386 {
34387 if (temp3)
34388 delete arg3;
34389 }
34390 return NULL;
34391 }
34392
34393
34394 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34395 PyObject *resultobj;
34396 wxMenu *arg1 = (wxMenu *) 0 ;
34397 int arg2 ;
34398 wxString result;
34399 PyObject * obj0 = 0 ;
34400 PyObject * obj1 = 0 ;
34401 char *kwnames[] = {
34402 (char *) "self",(char *) "id", NULL
34403 };
34404
34405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34407 if (SWIG_arg_fail(1)) SWIG_fail;
34408 {
34409 arg2 = (int)(SWIG_As_int(obj1));
34410 if (SWIG_arg_fail(2)) SWIG_fail;
34411 }
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34415
34416 wxPyEndAllowThreads(__tstate);
34417 if (PyErr_Occurred()) SWIG_fail;
34418 }
34419 {
34420 #if wxUSE_UNICODE
34421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34422 #else
34423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34424 #endif
34425 }
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34433 PyObject *resultobj;
34434 wxMenu *arg1 = (wxMenu *) 0 ;
34435 int arg2 ;
34436 wxString *arg3 = 0 ;
34437 bool temp3 = false ;
34438 PyObject * obj0 = 0 ;
34439 PyObject * obj1 = 0 ;
34440 PyObject * obj2 = 0 ;
34441 char *kwnames[] = {
34442 (char *) "self",(char *) "id",(char *) "helpString", NULL
34443 };
34444
34445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34447 if (SWIG_arg_fail(1)) SWIG_fail;
34448 {
34449 arg2 = (int)(SWIG_As_int(obj1));
34450 if (SWIG_arg_fail(2)) SWIG_fail;
34451 }
34452 {
34453 arg3 = wxString_in_helper(obj2);
34454 if (arg3 == NULL) SWIG_fail;
34455 temp3 = true;
34456 }
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34460
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 Py_INCREF(Py_None); resultobj = Py_None;
34465 {
34466 if (temp3)
34467 delete arg3;
34468 }
34469 return resultobj;
34470 fail:
34471 {
34472 if (temp3)
34473 delete arg3;
34474 }
34475 return NULL;
34476 }
34477
34478
34479 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34480 PyObject *resultobj;
34481 wxMenu *arg1 = (wxMenu *) 0 ;
34482 int arg2 ;
34483 wxString result;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 char *kwnames[] = {
34487 (char *) "self",(char *) "id", NULL
34488 };
34489
34490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34492 if (SWIG_arg_fail(1)) SWIG_fail;
34493 {
34494 arg2 = (int)(SWIG_As_int(obj1));
34495 if (SWIG_arg_fail(2)) SWIG_fail;
34496 }
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34500
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 {
34505 #if wxUSE_UNICODE
34506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34507 #else
34508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34509 #endif
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj;
34519 wxMenu *arg1 = (wxMenu *) 0 ;
34520 wxString *arg2 = 0 ;
34521 bool temp2 = false ;
34522 PyObject * obj0 = 0 ;
34523 PyObject * obj1 = 0 ;
34524 char *kwnames[] = {
34525 (char *) "self",(char *) "title", NULL
34526 };
34527
34528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34530 if (SWIG_arg_fail(1)) SWIG_fail;
34531 {
34532 arg2 = wxString_in_helper(obj1);
34533 if (arg2 == NULL) SWIG_fail;
34534 temp2 = true;
34535 }
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 (arg1)->SetTitle((wxString const &)*arg2);
34539
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 Py_INCREF(Py_None); resultobj = Py_None;
34544 {
34545 if (temp2)
34546 delete arg2;
34547 }
34548 return resultobj;
34549 fail:
34550 {
34551 if (temp2)
34552 delete arg2;
34553 }
34554 return NULL;
34555 }
34556
34557
34558 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj;
34560 wxMenu *arg1 = (wxMenu *) 0 ;
34561 wxString result;
34562 PyObject * obj0 = 0 ;
34563 char *kwnames[] = {
34564 (char *) "self", NULL
34565 };
34566
34567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34569 if (SWIG_arg_fail(1)) SWIG_fail;
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 result = ((wxMenu const *)arg1)->GetTitle();
34573
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 {
34578 #if wxUSE_UNICODE
34579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34580 #else
34581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34582 #endif
34583 }
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenu *arg1 = (wxMenu *) 0 ;
34593 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34594 PyObject * obj0 = 0 ;
34595 PyObject * obj1 = 0 ;
34596 char *kwnames[] = {
34597 (char *) "self",(char *) "handler", NULL
34598 };
34599
34600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34602 if (SWIG_arg_fail(1)) SWIG_fail;
34603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34604 if (SWIG_arg_fail(2)) SWIG_fail;
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 (arg1)->SetEventHandler(arg2);
34608
34609 wxPyEndAllowThreads(__tstate);
34610 if (PyErr_Occurred()) SWIG_fail;
34611 }
34612 Py_INCREF(Py_None); resultobj = Py_None;
34613 return resultobj;
34614 fail:
34615 return NULL;
34616 }
34617
34618
34619 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34620 PyObject *resultobj;
34621 wxMenu *arg1 = (wxMenu *) 0 ;
34622 wxEvtHandler *result;
34623 PyObject * obj0 = 0 ;
34624 char *kwnames[] = {
34625 (char *) "self", NULL
34626 };
34627
34628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34630 if (SWIG_arg_fail(1)) SWIG_fail;
34631 {
34632 PyThreadState* __tstate = wxPyBeginAllowThreads();
34633 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34634
34635 wxPyEndAllowThreads(__tstate);
34636 if (PyErr_Occurred()) SWIG_fail;
34637 }
34638 {
34639 resultobj = wxPyMake_wxObject(result, 0);
34640 }
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj;
34649 wxMenu *arg1 = (wxMenu *) 0 ;
34650 wxWindow *arg2 = (wxWindow *) 0 ;
34651 PyObject * obj0 = 0 ;
34652 PyObject * obj1 = 0 ;
34653 char *kwnames[] = {
34654 (char *) "self",(char *) "win", NULL
34655 };
34656
34657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34659 if (SWIG_arg_fail(1)) SWIG_fail;
34660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34661 if (SWIG_arg_fail(2)) SWIG_fail;
34662 {
34663 PyThreadState* __tstate = wxPyBeginAllowThreads();
34664 (arg1)->SetInvokingWindow(arg2);
34665
34666 wxPyEndAllowThreads(__tstate);
34667 if (PyErr_Occurred()) SWIG_fail;
34668 }
34669 Py_INCREF(Py_None); resultobj = Py_None;
34670 return resultobj;
34671 fail:
34672 return NULL;
34673 }
34674
34675
34676 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34677 PyObject *resultobj;
34678 wxMenu *arg1 = (wxMenu *) 0 ;
34679 wxWindow *result;
34680 PyObject * obj0 = 0 ;
34681 char *kwnames[] = {
34682 (char *) "self", NULL
34683 };
34684
34685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34687 if (SWIG_arg_fail(1)) SWIG_fail;
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34691
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 {
34696 resultobj = wxPyMake_wxObject(result, 0);
34697 }
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj;
34706 wxMenu *arg1 = (wxMenu *) 0 ;
34707 long result;
34708 PyObject * obj0 = 0 ;
34709 char *kwnames[] = {
34710 (char *) "self", NULL
34711 };
34712
34713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34715 if (SWIG_arg_fail(1)) SWIG_fail;
34716 {
34717 PyThreadState* __tstate = wxPyBeginAllowThreads();
34718 result = (long)((wxMenu const *)arg1)->GetStyle();
34719
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 {
34724 resultobj = SWIG_From_long((long)(result));
34725 }
34726 return resultobj;
34727 fail:
34728 return NULL;
34729 }
34730
34731
34732 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34733 PyObject *resultobj;
34734 wxMenu *arg1 = (wxMenu *) 0 ;
34735 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 char *kwnames[] = {
34739 (char *) "self",(char *) "source", NULL
34740 };
34741
34742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34744 if (SWIG_arg_fail(1)) SWIG_fail;
34745 if (obj1) {
34746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34747 if (SWIG_arg_fail(2)) SWIG_fail;
34748 }
34749 {
34750 PyThreadState* __tstate = wxPyBeginAllowThreads();
34751 (arg1)->UpdateUI(arg2);
34752
34753 wxPyEndAllowThreads(__tstate);
34754 if (PyErr_Occurred()) SWIG_fail;
34755 }
34756 Py_INCREF(Py_None); resultobj = Py_None;
34757 return resultobj;
34758 fail:
34759 return NULL;
34760 }
34761
34762
34763 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34764 PyObject *resultobj;
34765 wxMenu *arg1 = (wxMenu *) 0 ;
34766 wxMenuBar *result;
34767 PyObject * obj0 = 0 ;
34768 char *kwnames[] = {
34769 (char *) "self", NULL
34770 };
34771
34772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34774 if (SWIG_arg_fail(1)) SWIG_fail;
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34778
34779 wxPyEndAllowThreads(__tstate);
34780 if (PyErr_Occurred()) SWIG_fail;
34781 }
34782 {
34783 resultobj = wxPyMake_wxObject(result, 0);
34784 }
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34792 PyObject *resultobj;
34793 wxMenu *arg1 = (wxMenu *) 0 ;
34794 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34795 PyObject * obj0 = 0 ;
34796 PyObject * obj1 = 0 ;
34797 char *kwnames[] = {
34798 (char *) "self",(char *) "menubar", NULL
34799 };
34800
34801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34803 if (SWIG_arg_fail(1)) SWIG_fail;
34804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34805 if (SWIG_arg_fail(2)) SWIG_fail;
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 (arg1)->Attach(arg2);
34809
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 Py_INCREF(Py_None); resultobj = Py_None;
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34821 PyObject *resultobj;
34822 wxMenu *arg1 = (wxMenu *) 0 ;
34823 PyObject * obj0 = 0 ;
34824 char *kwnames[] = {
34825 (char *) "self", NULL
34826 };
34827
34828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34830 if (SWIG_arg_fail(1)) SWIG_fail;
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 (arg1)->Detach();
34834
34835 wxPyEndAllowThreads(__tstate);
34836 if (PyErr_Occurred()) SWIG_fail;
34837 }
34838 Py_INCREF(Py_None); resultobj = Py_None;
34839 return resultobj;
34840 fail:
34841 return NULL;
34842 }
34843
34844
34845 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34846 PyObject *resultobj;
34847 wxMenu *arg1 = (wxMenu *) 0 ;
34848 bool result;
34849 PyObject * obj0 = 0 ;
34850 char *kwnames[] = {
34851 (char *) "self", NULL
34852 };
34853
34854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34856 if (SWIG_arg_fail(1)) SWIG_fail;
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = (bool)((wxMenu const *)arg1)->IsAttached();
34860
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 {
34865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34866 }
34867 return resultobj;
34868 fail:
34869 return NULL;
34870 }
34871
34872
34873 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj;
34875 wxMenu *arg1 = (wxMenu *) 0 ;
34876 wxMenu *arg2 = (wxMenu *) 0 ;
34877 PyObject * obj0 = 0 ;
34878 PyObject * obj1 = 0 ;
34879 char *kwnames[] = {
34880 (char *) "self",(char *) "parent", NULL
34881 };
34882
34883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34885 if (SWIG_arg_fail(1)) SWIG_fail;
34886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34887 if (SWIG_arg_fail(2)) SWIG_fail;
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 (arg1)->SetParent(arg2);
34891
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 Py_INCREF(Py_None); resultobj = Py_None;
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj;
34904 wxMenu *arg1 = (wxMenu *) 0 ;
34905 wxMenu *result;
34906 PyObject * obj0 = 0 ;
34907 char *kwnames[] = {
34908 (char *) "self", NULL
34909 };
34910
34911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34913 if (SWIG_arg_fail(1)) SWIG_fail;
34914 {
34915 PyThreadState* __tstate = wxPyBeginAllowThreads();
34916 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34917
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 {
34922 resultobj = wxPyMake_wxObject(result, 0);
34923 }
34924 return resultobj;
34925 fail:
34926 return NULL;
34927 }
34928
34929
34930 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34931 PyObject *obj;
34932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34933 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34934 Py_INCREF(obj);
34935 return Py_BuildValue((char *)"");
34936 }
34937 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34938 PyObject *resultobj;
34939 long arg1 = (long) 0 ;
34940 wxMenuBar *result;
34941 PyObject * obj0 = 0 ;
34942 char *kwnames[] = {
34943 (char *) "style", NULL
34944 };
34945
34946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34947 if (obj0) {
34948 {
34949 arg1 = (long)(SWIG_As_long(obj0));
34950 if (SWIG_arg_fail(1)) SWIG_fail;
34951 }
34952 }
34953 {
34954 if (!wxPyCheckForApp()) SWIG_fail;
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (wxMenuBar *)new wxMenuBar(arg1);
34957
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34969 PyObject *resultobj;
34970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34971 wxMenu *arg2 = (wxMenu *) 0 ;
34972 wxString *arg3 = 0 ;
34973 bool result;
34974 bool temp3 = false ;
34975 PyObject * obj0 = 0 ;
34976 PyObject * obj1 = 0 ;
34977 PyObject * obj2 = 0 ;
34978 char *kwnames[] = {
34979 (char *) "self",(char *) "menu",(char *) "title", NULL
34980 };
34981
34982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34984 if (SWIG_arg_fail(1)) SWIG_fail;
34985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34986 if (SWIG_arg_fail(2)) SWIG_fail;
34987 {
34988 arg3 = wxString_in_helper(obj2);
34989 if (arg3 == NULL) SWIG_fail;
34990 temp3 = true;
34991 }
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34995
34996 wxPyEndAllowThreads(__tstate);
34997 if (PyErr_Occurred()) SWIG_fail;
34998 }
34999 {
35000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35001 }
35002 {
35003 if (temp3)
35004 delete arg3;
35005 }
35006 return resultobj;
35007 fail:
35008 {
35009 if (temp3)
35010 delete arg3;
35011 }
35012 return NULL;
35013 }
35014
35015
35016 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35017 PyObject *resultobj;
35018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35019 size_t arg2 ;
35020 wxMenu *arg3 = (wxMenu *) 0 ;
35021 wxString *arg4 = 0 ;
35022 bool result;
35023 bool temp4 = false ;
35024 PyObject * obj0 = 0 ;
35025 PyObject * obj1 = 0 ;
35026 PyObject * obj2 = 0 ;
35027 PyObject * obj3 = 0 ;
35028 char *kwnames[] = {
35029 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35030 };
35031
35032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35034 if (SWIG_arg_fail(1)) SWIG_fail;
35035 {
35036 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35037 if (SWIG_arg_fail(2)) SWIG_fail;
35038 }
35039 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35040 if (SWIG_arg_fail(3)) SWIG_fail;
35041 {
35042 arg4 = wxString_in_helper(obj3);
35043 if (arg4 == NULL) SWIG_fail;
35044 temp4 = true;
35045 }
35046 {
35047 PyThreadState* __tstate = wxPyBeginAllowThreads();
35048 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35049
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 {
35054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35055 }
35056 {
35057 if (temp4)
35058 delete arg4;
35059 }
35060 return resultobj;
35061 fail:
35062 {
35063 if (temp4)
35064 delete arg4;
35065 }
35066 return NULL;
35067 }
35068
35069
35070 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35071 PyObject *resultobj;
35072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35073 size_t result;
35074 PyObject * obj0 = 0 ;
35075 char *kwnames[] = {
35076 (char *) "self", NULL
35077 };
35078
35079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35081 if (SWIG_arg_fail(1)) SWIG_fail;
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35085
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 {
35090 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35091 }
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj;
35100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35101 size_t arg2 ;
35102 wxMenu *result;
35103 PyObject * obj0 = 0 ;
35104 PyObject * obj1 = 0 ;
35105 char *kwnames[] = {
35106 (char *) "self",(char *) "pos", NULL
35107 };
35108
35109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35111 if (SWIG_arg_fail(1)) SWIG_fail;
35112 {
35113 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35114 if (SWIG_arg_fail(2)) SWIG_fail;
35115 }
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35119
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 {
35124 resultobj = wxPyMake_wxObject(result, 0);
35125 }
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj;
35134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35135 size_t arg2 ;
35136 wxMenu *arg3 = (wxMenu *) 0 ;
35137 wxString *arg4 = 0 ;
35138 wxMenu *result;
35139 bool temp4 = false ;
35140 PyObject * obj0 = 0 ;
35141 PyObject * obj1 = 0 ;
35142 PyObject * obj2 = 0 ;
35143 PyObject * obj3 = 0 ;
35144 char *kwnames[] = {
35145 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35146 };
35147
35148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35150 if (SWIG_arg_fail(1)) SWIG_fail;
35151 {
35152 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35153 if (SWIG_arg_fail(2)) SWIG_fail;
35154 }
35155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35156 if (SWIG_arg_fail(3)) SWIG_fail;
35157 {
35158 arg4 = wxString_in_helper(obj3);
35159 if (arg4 == NULL) SWIG_fail;
35160 temp4 = true;
35161 }
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35165
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 {
35170 resultobj = wxPyMake_wxObject(result, 0);
35171 }
35172 {
35173 if (temp4)
35174 delete arg4;
35175 }
35176 return resultobj;
35177 fail:
35178 {
35179 if (temp4)
35180 delete arg4;
35181 }
35182 return NULL;
35183 }
35184
35185
35186 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35187 PyObject *resultobj;
35188 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35189 size_t arg2 ;
35190 wxMenu *result;
35191 PyObject * obj0 = 0 ;
35192 PyObject * obj1 = 0 ;
35193 char *kwnames[] = {
35194 (char *) "self",(char *) "pos", NULL
35195 };
35196
35197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35199 if (SWIG_arg_fail(1)) SWIG_fail;
35200 {
35201 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35202 if (SWIG_arg_fail(2)) SWIG_fail;
35203 }
35204 {
35205 PyThreadState* __tstate = wxPyBeginAllowThreads();
35206 result = (wxMenu *)(arg1)->Remove(arg2);
35207
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 {
35212 resultobj = wxPyMake_wxObject(result, 0);
35213 }
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj;
35222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35223 size_t arg2 ;
35224 bool arg3 ;
35225 PyObject * obj0 = 0 ;
35226 PyObject * obj1 = 0 ;
35227 PyObject * obj2 = 0 ;
35228 char *kwnames[] = {
35229 (char *) "self",(char *) "pos",(char *) "enable", NULL
35230 };
35231
35232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35234 if (SWIG_arg_fail(1)) SWIG_fail;
35235 {
35236 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35237 if (SWIG_arg_fail(2)) SWIG_fail;
35238 }
35239 {
35240 arg3 = (bool)(SWIG_As_bool(obj2));
35241 if (SWIG_arg_fail(3)) SWIG_fail;
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->EnableTop(arg2,arg3);
35246
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 Py_INCREF(Py_None); resultobj = Py_None;
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj;
35259 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35260 size_t arg2 ;
35261 bool result;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 char *kwnames[] = {
35265 (char *) "self",(char *) "pos", NULL
35266 };
35267
35268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35270 if (SWIG_arg_fail(1)) SWIG_fail;
35271 {
35272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35273 if (SWIG_arg_fail(2)) SWIG_fail;
35274 }
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35278
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 {
35283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35284 }
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj;
35293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35294 size_t arg2 ;
35295 wxString *arg3 = 0 ;
35296 bool temp3 = false ;
35297 PyObject * obj0 = 0 ;
35298 PyObject * obj1 = 0 ;
35299 PyObject * obj2 = 0 ;
35300 char *kwnames[] = {
35301 (char *) "self",(char *) "pos",(char *) "label", NULL
35302 };
35303
35304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35306 if (SWIG_arg_fail(1)) SWIG_fail;
35307 {
35308 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35309 if (SWIG_arg_fail(2)) SWIG_fail;
35310 }
35311 {
35312 arg3 = wxString_in_helper(obj2);
35313 if (arg3 == NULL) SWIG_fail;
35314 temp3 = true;
35315 }
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35319
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 Py_INCREF(Py_None); resultobj = Py_None;
35324 {
35325 if (temp3)
35326 delete arg3;
35327 }
35328 return resultobj;
35329 fail:
35330 {
35331 if (temp3)
35332 delete arg3;
35333 }
35334 return NULL;
35335 }
35336
35337
35338 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35339 PyObject *resultobj;
35340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35341 size_t arg2 ;
35342 wxString result;
35343 PyObject * obj0 = 0 ;
35344 PyObject * obj1 = 0 ;
35345 char *kwnames[] = {
35346 (char *) "self",(char *) "pos", NULL
35347 };
35348
35349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35351 if (SWIG_arg_fail(1)) SWIG_fail;
35352 {
35353 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35354 if (SWIG_arg_fail(2)) SWIG_fail;
35355 }
35356 {
35357 PyThreadState* __tstate = wxPyBeginAllowThreads();
35358 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35359
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 {
35364 #if wxUSE_UNICODE
35365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35366 #else
35367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35368 #endif
35369 }
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35377 PyObject *resultobj;
35378 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35379 wxString *arg2 = 0 ;
35380 wxString *arg3 = 0 ;
35381 int result;
35382 bool temp2 = false ;
35383 bool temp3 = false ;
35384 PyObject * obj0 = 0 ;
35385 PyObject * obj1 = 0 ;
35386 PyObject * obj2 = 0 ;
35387 char *kwnames[] = {
35388 (char *) "self",(char *) "menu",(char *) "item", NULL
35389 };
35390
35391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35393 if (SWIG_arg_fail(1)) SWIG_fail;
35394 {
35395 arg2 = wxString_in_helper(obj1);
35396 if (arg2 == NULL) SWIG_fail;
35397 temp2 = true;
35398 }
35399 {
35400 arg3 = wxString_in_helper(obj2);
35401 if (arg3 == NULL) SWIG_fail;
35402 temp3 = true;
35403 }
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35407
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 {
35412 resultobj = SWIG_From_int((int)(result));
35413 }
35414 {
35415 if (temp2)
35416 delete arg2;
35417 }
35418 {
35419 if (temp3)
35420 delete arg3;
35421 }
35422 return resultobj;
35423 fail:
35424 {
35425 if (temp2)
35426 delete arg2;
35427 }
35428 {
35429 if (temp3)
35430 delete arg3;
35431 }
35432 return NULL;
35433 }
35434
35435
35436 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35437 PyObject *resultobj;
35438 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35439 int arg2 ;
35440 wxMenuItem *result;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char *kwnames[] = {
35444 (char *) "self",(char *) "id", NULL
35445 };
35446
35447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35449 if (SWIG_arg_fail(1)) SWIG_fail;
35450 {
35451 arg2 = (int)(SWIG_As_int(obj1));
35452 if (SWIG_arg_fail(2)) SWIG_fail;
35453 }
35454 {
35455 PyThreadState* __tstate = wxPyBeginAllowThreads();
35456 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35457
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 {
35462 resultobj = wxPyMake_wxObject(result, 0);
35463 }
35464 return resultobj;
35465 fail:
35466 return NULL;
35467 }
35468
35469
35470 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35471 PyObject *resultobj;
35472 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35473 wxString *arg2 = 0 ;
35474 int result;
35475 bool temp2 = false ;
35476 PyObject * obj0 = 0 ;
35477 PyObject * obj1 = 0 ;
35478 char *kwnames[] = {
35479 (char *) "self",(char *) "title", NULL
35480 };
35481
35482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35484 if (SWIG_arg_fail(1)) SWIG_fail;
35485 {
35486 arg2 = wxString_in_helper(obj1);
35487 if (arg2 == NULL) SWIG_fail;
35488 temp2 = true;
35489 }
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35493
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 {
35498 resultobj = SWIG_From_int((int)(result));
35499 }
35500 {
35501 if (temp2)
35502 delete arg2;
35503 }
35504 return resultobj;
35505 fail:
35506 {
35507 if (temp2)
35508 delete arg2;
35509 }
35510 return NULL;
35511 }
35512
35513
35514 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35515 PyObject *resultobj;
35516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35517 int arg2 ;
35518 bool arg3 ;
35519 PyObject * obj0 = 0 ;
35520 PyObject * obj1 = 0 ;
35521 PyObject * obj2 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self",(char *) "id",(char *) "enable", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 arg2 = (int)(SWIG_As_int(obj1));
35531 if (SWIG_arg_fail(2)) SWIG_fail;
35532 }
35533 {
35534 arg3 = (bool)(SWIG_As_bool(obj2));
35535 if (SWIG_arg_fail(3)) SWIG_fail;
35536 }
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 (arg1)->Enable(arg2,arg3);
35540
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 Py_INCREF(Py_None); resultobj = Py_None;
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj;
35553 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35554 int arg2 ;
35555 bool arg3 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 PyObject * obj2 = 0 ;
35559 char *kwnames[] = {
35560 (char *) "self",(char *) "id",(char *) "check", NULL
35561 };
35562
35563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35565 if (SWIG_arg_fail(1)) SWIG_fail;
35566 {
35567 arg2 = (int)(SWIG_As_int(obj1));
35568 if (SWIG_arg_fail(2)) SWIG_fail;
35569 }
35570 {
35571 arg3 = (bool)(SWIG_As_bool(obj2));
35572 if (SWIG_arg_fail(3)) SWIG_fail;
35573 }
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->Check(arg2,arg3);
35577
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 Py_INCREF(Py_None); resultobj = Py_None;
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35589 PyObject *resultobj;
35590 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35591 int arg2 ;
35592 bool result;
35593 PyObject * obj0 = 0 ;
35594 PyObject * obj1 = 0 ;
35595 char *kwnames[] = {
35596 (char *) "self",(char *) "id", NULL
35597 };
35598
35599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35601 if (SWIG_arg_fail(1)) SWIG_fail;
35602 {
35603 arg2 = (int)(SWIG_As_int(obj1));
35604 if (SWIG_arg_fail(2)) SWIG_fail;
35605 }
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35609
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 {
35614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35615 }
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35623 PyObject *resultobj;
35624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35625 int arg2 ;
35626 bool result;
35627 PyObject * obj0 = 0 ;
35628 PyObject * obj1 = 0 ;
35629 char *kwnames[] = {
35630 (char *) "self",(char *) "id", NULL
35631 };
35632
35633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35635 if (SWIG_arg_fail(1)) SWIG_fail;
35636 {
35637 arg2 = (int)(SWIG_As_int(obj1));
35638 if (SWIG_arg_fail(2)) SWIG_fail;
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35643
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35659 int arg2 ;
35660 wxString *arg3 = 0 ;
35661 bool temp3 = false ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 PyObject * obj2 = 0 ;
35665 char *kwnames[] = {
35666 (char *) "self",(char *) "id",(char *) "label", NULL
35667 };
35668
35669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35671 if (SWIG_arg_fail(1)) SWIG_fail;
35672 {
35673 arg2 = (int)(SWIG_As_int(obj1));
35674 if (SWIG_arg_fail(2)) SWIG_fail;
35675 }
35676 {
35677 arg3 = wxString_in_helper(obj2);
35678 if (arg3 == NULL) SWIG_fail;
35679 temp3 = true;
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35684
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 Py_INCREF(Py_None); resultobj = Py_None;
35689 {
35690 if (temp3)
35691 delete arg3;
35692 }
35693 return resultobj;
35694 fail:
35695 {
35696 if (temp3)
35697 delete arg3;
35698 }
35699 return NULL;
35700 }
35701
35702
35703 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35704 PyObject *resultobj;
35705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35706 int arg2 ;
35707 wxString result;
35708 PyObject * obj0 = 0 ;
35709 PyObject * obj1 = 0 ;
35710 char *kwnames[] = {
35711 (char *) "self",(char *) "id", NULL
35712 };
35713
35714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35716 if (SWIG_arg_fail(1)) SWIG_fail;
35717 {
35718 arg2 = (int)(SWIG_As_int(obj1));
35719 if (SWIG_arg_fail(2)) SWIG_fail;
35720 }
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35724
35725 wxPyEndAllowThreads(__tstate);
35726 if (PyErr_Occurred()) SWIG_fail;
35727 }
35728 {
35729 #if wxUSE_UNICODE
35730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35731 #else
35732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35733 #endif
35734 }
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35742 PyObject *resultobj;
35743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35744 int arg2 ;
35745 wxString *arg3 = 0 ;
35746 bool temp3 = false ;
35747 PyObject * obj0 = 0 ;
35748 PyObject * obj1 = 0 ;
35749 PyObject * obj2 = 0 ;
35750 char *kwnames[] = {
35751 (char *) "self",(char *) "id",(char *) "helpString", NULL
35752 };
35753
35754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35756 if (SWIG_arg_fail(1)) SWIG_fail;
35757 {
35758 arg2 = (int)(SWIG_As_int(obj1));
35759 if (SWIG_arg_fail(2)) SWIG_fail;
35760 }
35761 {
35762 arg3 = wxString_in_helper(obj2);
35763 if (arg3 == NULL) SWIG_fail;
35764 temp3 = true;
35765 }
35766 {
35767 PyThreadState* __tstate = wxPyBeginAllowThreads();
35768 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35769
35770 wxPyEndAllowThreads(__tstate);
35771 if (PyErr_Occurred()) SWIG_fail;
35772 }
35773 Py_INCREF(Py_None); resultobj = Py_None;
35774 {
35775 if (temp3)
35776 delete arg3;
35777 }
35778 return resultobj;
35779 fail:
35780 {
35781 if (temp3)
35782 delete arg3;
35783 }
35784 return NULL;
35785 }
35786
35787
35788 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35789 PyObject *resultobj;
35790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35791 int arg2 ;
35792 wxString result;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self",(char *) "id", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 arg2 = (int)(SWIG_As_int(obj1));
35804 if (SWIG_arg_fail(2)) SWIG_fail;
35805 }
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35809
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 {
35814 #if wxUSE_UNICODE
35815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35816 #else
35817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35818 #endif
35819 }
35820 return resultobj;
35821 fail:
35822 return NULL;
35823 }
35824
35825
35826 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35827 PyObject *resultobj;
35828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35829 wxFrame *result;
35830 PyObject * obj0 = 0 ;
35831 char *kwnames[] = {
35832 (char *) "self", NULL
35833 };
35834
35835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35837 if (SWIG_arg_fail(1)) SWIG_fail;
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35841
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 {
35846 resultobj = wxPyMake_wxObject(result, 0);
35847 }
35848 return resultobj;
35849 fail:
35850 return NULL;
35851 }
35852
35853
35854 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj;
35856 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35857 bool result;
35858 PyObject * obj0 = 0 ;
35859 char *kwnames[] = {
35860 (char *) "self", NULL
35861 };
35862
35863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35865 if (SWIG_arg_fail(1)) SWIG_fail;
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35869
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 {
35874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35875 }
35876 return resultobj;
35877 fail:
35878 return NULL;
35879 }
35880
35881
35882 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35883 PyObject *resultobj;
35884 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35885 wxFrame *arg2 = (wxFrame *) 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 char *kwnames[] = {
35889 (char *) "self",(char *) "frame", NULL
35890 };
35891
35892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35894 if (SWIG_arg_fail(1)) SWIG_fail;
35895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35896 if (SWIG_arg_fail(2)) SWIG_fail;
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->Attach(arg2);
35900
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 Py_INCREF(Py_None); resultobj = Py_None;
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj;
35913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35914 PyObject * obj0 = 0 ;
35915 char *kwnames[] = {
35916 (char *) "self", NULL
35917 };
35918
35919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35921 if (SWIG_arg_fail(1)) SWIG_fail;
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 (arg1)->Detach();
35925
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 Py_INCREF(Py_None); resultobj = Py_None;
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35937 PyObject *obj;
35938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35939 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35940 Py_INCREF(obj);
35941 return Py_BuildValue((char *)"");
35942 }
35943 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj;
35945 wxMenu *arg1 = (wxMenu *) NULL ;
35946 int arg2 = (int) wxID_ANY ;
35947 wxString const &arg3_defvalue = wxPyEmptyString ;
35948 wxString *arg3 = (wxString *) &arg3_defvalue ;
35949 wxString const &arg4_defvalue = wxPyEmptyString ;
35950 wxString *arg4 = (wxString *) &arg4_defvalue ;
35951 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35952 wxMenu *arg6 = (wxMenu *) NULL ;
35953 wxMenuItem *result;
35954 bool temp3 = false ;
35955 bool temp4 = false ;
35956 PyObject * obj0 = 0 ;
35957 PyObject * obj1 = 0 ;
35958 PyObject * obj2 = 0 ;
35959 PyObject * obj3 = 0 ;
35960 PyObject * obj4 = 0 ;
35961 PyObject * obj5 = 0 ;
35962 char *kwnames[] = {
35963 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35964 };
35965
35966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35967 if (obj0) {
35968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35969 if (SWIG_arg_fail(1)) SWIG_fail;
35970 }
35971 if (obj1) {
35972 {
35973 arg2 = (int)(SWIG_As_int(obj1));
35974 if (SWIG_arg_fail(2)) SWIG_fail;
35975 }
35976 }
35977 if (obj2) {
35978 {
35979 arg3 = wxString_in_helper(obj2);
35980 if (arg3 == NULL) SWIG_fail;
35981 temp3 = true;
35982 }
35983 }
35984 if (obj3) {
35985 {
35986 arg4 = wxString_in_helper(obj3);
35987 if (arg4 == NULL) SWIG_fail;
35988 temp4 = true;
35989 }
35990 }
35991 if (obj4) {
35992 {
35993 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35994 if (SWIG_arg_fail(5)) SWIG_fail;
35995 }
35996 }
35997 if (obj5) {
35998 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35999 if (SWIG_arg_fail(6)) SWIG_fail;
36000 }
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36004
36005 wxPyEndAllowThreads(__tstate);
36006 if (PyErr_Occurred()) SWIG_fail;
36007 }
36008 {
36009 resultobj = wxPyMake_wxObject(result, 1);
36010 }
36011 {
36012 if (temp3)
36013 delete arg3;
36014 }
36015 {
36016 if (temp4)
36017 delete arg4;
36018 }
36019 return resultobj;
36020 fail:
36021 {
36022 if (temp3)
36023 delete arg3;
36024 }
36025 {
36026 if (temp4)
36027 delete arg4;
36028 }
36029 return NULL;
36030 }
36031
36032
36033 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj;
36035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36036 wxMenu *result;
36037 PyObject * obj0 = 0 ;
36038 char *kwnames[] = {
36039 (char *) "self", NULL
36040 };
36041
36042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36044 if (SWIG_arg_fail(1)) SWIG_fail;
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36048
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = wxPyMake_wxObject(result, 0);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj;
36063 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36064 wxMenu *arg2 = (wxMenu *) 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char *kwnames[] = {
36068 (char *) "self",(char *) "menu", NULL
36069 };
36070
36071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36073 if (SWIG_arg_fail(1)) SWIG_fail;
36074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36075 if (SWIG_arg_fail(2)) SWIG_fail;
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 (arg1)->SetMenu(arg2);
36079
36080 wxPyEndAllowThreads(__tstate);
36081 if (PyErr_Occurred()) SWIG_fail;
36082 }
36083 Py_INCREF(Py_None); resultobj = Py_None;
36084 return resultobj;
36085 fail:
36086 return NULL;
36087 }
36088
36089
36090 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36091 PyObject *resultobj;
36092 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36093 int arg2 ;
36094 PyObject * obj0 = 0 ;
36095 PyObject * obj1 = 0 ;
36096 char *kwnames[] = {
36097 (char *) "self",(char *) "id", NULL
36098 };
36099
36100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36102 if (SWIG_arg_fail(1)) SWIG_fail;
36103 {
36104 arg2 = (int)(SWIG_As_int(obj1));
36105 if (SWIG_arg_fail(2)) SWIG_fail;
36106 }
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 (arg1)->SetId(arg2);
36110
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 Py_INCREF(Py_None); resultobj = Py_None;
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36122 PyObject *resultobj;
36123 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36124 int result;
36125 PyObject * obj0 = 0 ;
36126 char *kwnames[] = {
36127 (char *) "self", NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36132 if (SWIG_arg_fail(1)) SWIG_fail;
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 result = (int)((wxMenuItem const *)arg1)->GetId();
36136
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 {
36141 resultobj = SWIG_From_int((int)(result));
36142 }
36143 return resultobj;
36144 fail:
36145 return NULL;
36146 }
36147
36148
36149 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36150 PyObject *resultobj;
36151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36152 bool result;
36153 PyObject * obj0 = 0 ;
36154 char *kwnames[] = {
36155 (char *) "self", NULL
36156 };
36157
36158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(1)) SWIG_fail;
36161 {
36162 PyThreadState* __tstate = wxPyBeginAllowThreads();
36163 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36164
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 {
36169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36170 }
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36178 PyObject *resultobj;
36179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36180 wxString *arg2 = 0 ;
36181 bool temp2 = false ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 char *kwnames[] = {
36185 (char *) "self",(char *) "str", NULL
36186 };
36187
36188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36190 if (SWIG_arg_fail(1)) SWIG_fail;
36191 {
36192 arg2 = wxString_in_helper(obj1);
36193 if (arg2 == NULL) SWIG_fail;
36194 temp2 = true;
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 (arg1)->SetText((wxString const &)*arg2);
36199
36200 wxPyEndAllowThreads(__tstate);
36201 if (PyErr_Occurred()) SWIG_fail;
36202 }
36203 Py_INCREF(Py_None); resultobj = Py_None;
36204 {
36205 if (temp2)
36206 delete arg2;
36207 }
36208 return resultobj;
36209 fail:
36210 {
36211 if (temp2)
36212 delete arg2;
36213 }
36214 return NULL;
36215 }
36216
36217
36218 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36219 PyObject *resultobj;
36220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36221 wxString result;
36222 PyObject * obj0 = 0 ;
36223 char *kwnames[] = {
36224 (char *) "self", NULL
36225 };
36226
36227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36229 if (SWIG_arg_fail(1)) SWIG_fail;
36230 {
36231 PyThreadState* __tstate = wxPyBeginAllowThreads();
36232 result = ((wxMenuItem const *)arg1)->GetLabel();
36233
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 {
36238 #if wxUSE_UNICODE
36239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36240 #else
36241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36242 #endif
36243 }
36244 return resultobj;
36245 fail:
36246 return NULL;
36247 }
36248
36249
36250 static PyObject *_wrap_MenuItem_GetText(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_GetText",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 {
36265 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36266 result = (wxString *) &_result_ref;
36267 }
36268
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 {
36273 #if wxUSE_UNICODE
36274 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36275 #else
36276 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36277 #endif
36278 }
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj;
36287 wxString *arg1 = 0 ;
36288 wxString result;
36289 bool temp1 = false ;
36290 PyObject * obj0 = 0 ;
36291 char *kwnames[] = {
36292 (char *) "text", NULL
36293 };
36294
36295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36296 {
36297 arg1 = wxString_in_helper(obj0);
36298 if (arg1 == NULL) SWIG_fail;
36299 temp1 = true;
36300 }
36301 {
36302 PyThreadState* __tstate = wxPyBeginAllowThreads();
36303 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36304
36305 wxPyEndAllowThreads(__tstate);
36306 if (PyErr_Occurred()) SWIG_fail;
36307 }
36308 {
36309 #if wxUSE_UNICODE
36310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36311 #else
36312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36313 #endif
36314 }
36315 {
36316 if (temp1)
36317 delete arg1;
36318 }
36319 return resultobj;
36320 fail:
36321 {
36322 if (temp1)
36323 delete arg1;
36324 }
36325 return NULL;
36326 }
36327
36328
36329 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36330 PyObject *resultobj;
36331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36332 wxItemKind result;
36333 PyObject * obj0 = 0 ;
36334 char *kwnames[] = {
36335 (char *) "self", NULL
36336 };
36337
36338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36340 if (SWIG_arg_fail(1)) SWIG_fail;
36341 {
36342 PyThreadState* __tstate = wxPyBeginAllowThreads();
36343 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36344
36345 wxPyEndAllowThreads(__tstate);
36346 if (PyErr_Occurred()) SWIG_fail;
36347 }
36348 resultobj = SWIG_From_int((result));
36349 return resultobj;
36350 fail:
36351 return NULL;
36352 }
36353
36354
36355 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36356 PyObject *resultobj;
36357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36358 wxItemKind arg2 ;
36359 PyObject * obj0 = 0 ;
36360 PyObject * obj1 = 0 ;
36361 char *kwnames[] = {
36362 (char *) "self",(char *) "kind", NULL
36363 };
36364
36365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36367 if (SWIG_arg_fail(1)) SWIG_fail;
36368 {
36369 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36370 if (SWIG_arg_fail(2)) SWIG_fail;
36371 }
36372 {
36373 PyThreadState* __tstate = wxPyBeginAllowThreads();
36374 (arg1)->SetKind((wxItemKind )arg2);
36375
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 Py_INCREF(Py_None); resultobj = Py_None;
36380 return resultobj;
36381 fail:
36382 return NULL;
36383 }
36384
36385
36386 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36387 PyObject *resultobj;
36388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36389 bool arg2 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 char *kwnames[] = {
36393 (char *) "self",(char *) "checkable", NULL
36394 };
36395
36396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36398 if (SWIG_arg_fail(1)) SWIG_fail;
36399 {
36400 arg2 = (bool)(SWIG_As_bool(obj1));
36401 if (SWIG_arg_fail(2)) SWIG_fail;
36402 }
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 (arg1)->SetCheckable(arg2);
36406
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 Py_INCREF(Py_None); resultobj = Py_None;
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj;
36419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36420 bool result;
36421 PyObject * obj0 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36432
36433 wxPyEndAllowThreads(__tstate);
36434 if (PyErr_Occurred()) SWIG_fail;
36435 }
36436 {
36437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36438 }
36439 return resultobj;
36440 fail:
36441 return NULL;
36442 }
36443
36444
36445 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36446 PyObject *resultobj;
36447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36448 bool result;
36449 PyObject * obj0 = 0 ;
36450 char *kwnames[] = {
36451 (char *) "self", NULL
36452 };
36453
36454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36456 if (SWIG_arg_fail(1)) SWIG_fail;
36457 {
36458 PyThreadState* __tstate = wxPyBeginAllowThreads();
36459 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36460
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 {
36465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36466 }
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36474 PyObject *resultobj;
36475 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36476 wxMenu *arg2 = (wxMenu *) 0 ;
36477 PyObject * obj0 = 0 ;
36478 PyObject * obj1 = 0 ;
36479 char *kwnames[] = {
36480 (char *) "self",(char *) "menu", NULL
36481 };
36482
36483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36485 if (SWIG_arg_fail(1)) SWIG_fail;
36486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36487 if (SWIG_arg_fail(2)) SWIG_fail;
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 (arg1)->SetSubMenu(arg2);
36491
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 Py_INCREF(Py_None); resultobj = Py_None;
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj;
36504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36505 wxMenu *result;
36506 PyObject * obj0 = 0 ;
36507 char *kwnames[] = {
36508 (char *) "self", NULL
36509 };
36510
36511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36513 if (SWIG_arg_fail(1)) SWIG_fail;
36514 {
36515 PyThreadState* __tstate = wxPyBeginAllowThreads();
36516 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36517
36518 wxPyEndAllowThreads(__tstate);
36519 if (PyErr_Occurred()) SWIG_fail;
36520 }
36521 {
36522 resultobj = wxPyMake_wxObject(result, 0);
36523 }
36524 return resultobj;
36525 fail:
36526 return NULL;
36527 }
36528
36529
36530 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36531 PyObject *resultobj;
36532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36533 bool arg2 = (bool) true ;
36534 PyObject * obj0 = 0 ;
36535 PyObject * obj1 = 0 ;
36536 char *kwnames[] = {
36537 (char *) "self",(char *) "enable", NULL
36538 };
36539
36540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36542 if (SWIG_arg_fail(1)) SWIG_fail;
36543 if (obj1) {
36544 {
36545 arg2 = (bool)(SWIG_As_bool(obj1));
36546 if (SWIG_arg_fail(2)) SWIG_fail;
36547 }
36548 }
36549 {
36550 PyThreadState* __tstate = wxPyBeginAllowThreads();
36551 (arg1)->Enable(arg2);
36552
36553 wxPyEndAllowThreads(__tstate);
36554 if (PyErr_Occurred()) SWIG_fail;
36555 }
36556 Py_INCREF(Py_None); resultobj = Py_None;
36557 return resultobj;
36558 fail:
36559 return NULL;
36560 }
36561
36562
36563 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36564 PyObject *resultobj;
36565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36566 bool result;
36567 PyObject * obj0 = 0 ;
36568 char *kwnames[] = {
36569 (char *) "self", NULL
36570 };
36571
36572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) 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 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36578
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 {
36583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36584 }
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj;
36593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36594 bool arg2 = (bool) true ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 char *kwnames[] = {
36598 (char *) "self",(char *) "check", NULL
36599 };
36600
36601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36603 if (SWIG_arg_fail(1)) SWIG_fail;
36604 if (obj1) {
36605 {
36606 arg2 = (bool)(SWIG_As_bool(obj1));
36607 if (SWIG_arg_fail(2)) SWIG_fail;
36608 }
36609 }
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 (arg1)->Check(arg2);
36613
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 Py_INCREF(Py_None); resultobj = Py_None;
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36625 PyObject *resultobj;
36626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36627 bool result;
36628 PyObject * obj0 = 0 ;
36629 char *kwnames[] = {
36630 (char *) "self", NULL
36631 };
36632
36633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) 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 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36639
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 {
36644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj;
36654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36655 PyObject * obj0 = 0 ;
36656 char *kwnames[] = {
36657 (char *) "self", NULL
36658 };
36659
36660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36662 if (SWIG_arg_fail(1)) SWIG_fail;
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 (arg1)->Toggle();
36666
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 Py_INCREF(Py_None); resultobj = Py_None;
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj;
36679 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36680 wxString *arg2 = 0 ;
36681 bool temp2 = false ;
36682 PyObject * obj0 = 0 ;
36683 PyObject * obj1 = 0 ;
36684 char *kwnames[] = {
36685 (char *) "self",(char *) "str", NULL
36686 };
36687
36688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36690 if (SWIG_arg_fail(1)) SWIG_fail;
36691 {
36692 arg2 = wxString_in_helper(obj1);
36693 if (arg2 == NULL) SWIG_fail;
36694 temp2 = true;
36695 }
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 (arg1)->SetHelp((wxString const &)*arg2);
36699
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 Py_INCREF(Py_None); resultobj = Py_None;
36704 {
36705 if (temp2)
36706 delete arg2;
36707 }
36708 return resultobj;
36709 fail:
36710 {
36711 if (temp2)
36712 delete arg2;
36713 }
36714 return NULL;
36715 }
36716
36717
36718 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36719 PyObject *resultobj;
36720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36721 wxString *result;
36722 PyObject * obj0 = 0 ;
36723 char *kwnames[] = {
36724 (char *) "self", NULL
36725 };
36726
36727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36729 if (SWIG_arg_fail(1)) SWIG_fail;
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 {
36733 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36734 result = (wxString *) &_result_ref;
36735 }
36736
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 {
36741 #if wxUSE_UNICODE
36742 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36743 #else
36744 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36745 #endif
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj;
36755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36756 wxAcceleratorEntry *result;
36757 PyObject * obj0 = 0 ;
36758 char *kwnames[] = {
36759 (char *) "self", NULL
36760 };
36761
36762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36764 if (SWIG_arg_fail(1)) SWIG_fail;
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36768
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36773 return resultobj;
36774 fail:
36775 return NULL;
36776 }
36777
36778
36779 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj;
36781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36782 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36783 PyObject * obj0 = 0 ;
36784 PyObject * obj1 = 0 ;
36785 char *kwnames[] = {
36786 (char *) "self",(char *) "accel", NULL
36787 };
36788
36789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36791 if (SWIG_arg_fail(1)) SWIG_fail;
36792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36793 if (SWIG_arg_fail(2)) SWIG_fail;
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 (arg1)->SetAccel(arg2);
36797
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 Py_INCREF(Py_None); resultobj = Py_None;
36802 return resultobj;
36803 fail:
36804 return NULL;
36805 }
36806
36807
36808 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36809 PyObject *resultobj;
36810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36811 wxFont *arg2 = 0 ;
36812 PyObject * obj0 = 0 ;
36813 PyObject * obj1 = 0 ;
36814 char *kwnames[] = {
36815 (char *) "self",(char *) "font", NULL
36816 };
36817
36818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36820 if (SWIG_arg_fail(1)) SWIG_fail;
36821 {
36822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(2)) SWIG_fail;
36824 if (arg2 == NULL) {
36825 SWIG_null_ref("wxFont");
36826 }
36827 if (SWIG_arg_fail(2)) SWIG_fail;
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36832
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 Py_INCREF(Py_None); resultobj = Py_None;
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36844 PyObject *resultobj;
36845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36846 wxFont result;
36847 PyObject * obj0 = 0 ;
36848 char *kwnames[] = {
36849 (char *) "self", NULL
36850 };
36851
36852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36854 if (SWIG_arg_fail(1)) SWIG_fail;
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 result = wxMenuItem_GetFont(arg1);
36858
36859 wxPyEndAllowThreads(__tstate);
36860 if (PyErr_Occurred()) SWIG_fail;
36861 }
36862 {
36863 wxFont * resultptr;
36864 resultptr = new wxFont((wxFont &)(result));
36865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36866 }
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj;
36875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36876 wxColour *arg2 = 0 ;
36877 wxColour temp2 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char *kwnames[] = {
36881 (char *) "self",(char *) "colText", NULL
36882 };
36883
36884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
36889 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36890 }
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36894
36895 wxPyEndAllowThreads(__tstate);
36896 if (PyErr_Occurred()) SWIG_fail;
36897 }
36898 Py_INCREF(Py_None); resultobj = Py_None;
36899 return resultobj;
36900 fail:
36901 return NULL;
36902 }
36903
36904
36905 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36906 PyObject *resultobj;
36907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36908 wxColour result;
36909 PyObject * obj0 = 0 ;
36910 char *kwnames[] = {
36911 (char *) "self", NULL
36912 };
36913
36914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36916 if (SWIG_arg_fail(1)) SWIG_fail;
36917 {
36918 PyThreadState* __tstate = wxPyBeginAllowThreads();
36919 result = wxMenuItem_GetTextColour(arg1);
36920
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 {
36925 wxColour * resultptr;
36926 resultptr = new wxColour((wxColour &)(result));
36927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36928 }
36929 return resultobj;
36930 fail:
36931 return NULL;
36932 }
36933
36934
36935 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36936 PyObject *resultobj;
36937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36938 wxColour *arg2 = 0 ;
36939 wxColour temp2 ;
36940 PyObject * obj0 = 0 ;
36941 PyObject * obj1 = 0 ;
36942 char *kwnames[] = {
36943 (char *) "self",(char *) "colBack", NULL
36944 };
36945
36946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
36951 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36952 }
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36956
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 Py_INCREF(Py_None); resultobj = Py_None;
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj;
36969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36970 wxColour result;
36971 PyObject * obj0 = 0 ;
36972 char *kwnames[] = {
36973 (char *) "self", NULL
36974 };
36975
36976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36978 if (SWIG_arg_fail(1)) SWIG_fail;
36979 {
36980 PyThreadState* __tstate = wxPyBeginAllowThreads();
36981 result = wxMenuItem_GetBackgroundColour(arg1);
36982
36983 wxPyEndAllowThreads(__tstate);
36984 if (PyErr_Occurred()) SWIG_fail;
36985 }
36986 {
36987 wxColour * resultptr;
36988 resultptr = new wxColour((wxColour &)(result));
36989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36990 }
36991 return resultobj;
36992 fail:
36993 return NULL;
36994 }
36995
36996
36997 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36998 PyObject *resultobj;
36999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37000 wxBitmap *arg2 = 0 ;
37001 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37002 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 PyObject * obj2 = 0 ;
37006 char *kwnames[] = {
37007 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37008 };
37009
37010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37012 if (SWIG_arg_fail(1)) SWIG_fail;
37013 {
37014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37015 if (SWIG_arg_fail(2)) SWIG_fail;
37016 if (arg2 == NULL) {
37017 SWIG_null_ref("wxBitmap");
37018 }
37019 if (SWIG_arg_fail(2)) SWIG_fail;
37020 }
37021 if (obj2) {
37022 {
37023 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37024 if (SWIG_arg_fail(3)) SWIG_fail;
37025 if (arg3 == NULL) {
37026 SWIG_null_ref("wxBitmap");
37027 }
37028 if (SWIG_arg_fail(3)) SWIG_fail;
37029 }
37030 }
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37034
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 Py_INCREF(Py_None); resultobj = Py_None;
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj;
37047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37048 wxBitmap *arg2 = 0 ;
37049 PyObject * obj0 = 0 ;
37050 PyObject * obj1 = 0 ;
37051 char *kwnames[] = {
37052 (char *) "self",(char *) "bmpDisabled", NULL
37053 };
37054
37055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37057 if (SWIG_arg_fail(1)) SWIG_fail;
37058 {
37059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37060 if (SWIG_arg_fail(2)) SWIG_fail;
37061 if (arg2 == NULL) {
37062 SWIG_null_ref("wxBitmap");
37063 }
37064 if (SWIG_arg_fail(2)) SWIG_fail;
37065 }
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37069
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 Py_INCREF(Py_None); resultobj = Py_None;
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj;
37082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37083 wxBitmap *result;
37084 PyObject * obj0 = 0 ;
37085 char *kwnames[] = {
37086 (char *) "self", NULL
37087 };
37088
37089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37091 if (SWIG_arg_fail(1)) SWIG_fail;
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 {
37095 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37096 result = (wxBitmap *) &_result_ref;
37097 }
37098
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 {
37103 wxBitmap* resultptr = new wxBitmap(*result);
37104 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37105 }
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37113 PyObject *resultobj;
37114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37115 int arg2 ;
37116 PyObject * obj0 = 0 ;
37117 PyObject * obj1 = 0 ;
37118 char *kwnames[] = {
37119 (char *) "self",(char *) "nWidth", NULL
37120 };
37121
37122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37124 if (SWIG_arg_fail(1)) SWIG_fail;
37125 {
37126 arg2 = (int)(SWIG_As_int(obj1));
37127 if (SWIG_arg_fail(2)) SWIG_fail;
37128 }
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 wxMenuItem_SetMarginWidth(arg1,arg2);
37132
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 Py_INCREF(Py_None); resultobj = Py_None;
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37144 PyObject *resultobj;
37145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37146 int result;
37147 PyObject * obj0 = 0 ;
37148 char *kwnames[] = {
37149 (char *) "self", NULL
37150 };
37151
37152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37154 if (SWIG_arg_fail(1)) SWIG_fail;
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 result = (int)wxMenuItem_GetMarginWidth(arg1);
37158
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 resultobj = SWIG_From_int((int)(result));
37164 }
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37172 PyObject *resultobj;
37173 int result;
37174 char *kwnames[] = {
37175 NULL
37176 };
37177
37178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (int)MenuItem_GetDefaultMarginWidth();
37182
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 {
37187 resultobj = SWIG_From_int((int)(result));
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj;
37197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37198 bool result;
37199 PyObject * obj0 = 0 ;
37200 char *kwnames[] = {
37201 (char *) "self", NULL
37202 };
37203
37204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37206 if (SWIG_arg_fail(1)) SWIG_fail;
37207 {
37208 PyThreadState* __tstate = wxPyBeginAllowThreads();
37209 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37210
37211 wxPyEndAllowThreads(__tstate);
37212 if (PyErr_Occurred()) SWIG_fail;
37213 }
37214 {
37215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37216 }
37217 return resultobj;
37218 fail:
37219 return NULL;
37220 }
37221
37222
37223 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37224 PyObject *resultobj;
37225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37226 bool arg2 = (bool) true ;
37227 PyObject * obj0 = 0 ;
37228 PyObject * obj1 = 0 ;
37229 char *kwnames[] = {
37230 (char *) "self",(char *) "ownerDrawn", NULL
37231 };
37232
37233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37235 if (SWIG_arg_fail(1)) SWIG_fail;
37236 if (obj1) {
37237 {
37238 arg2 = (bool)(SWIG_As_bool(obj1));
37239 if (SWIG_arg_fail(2)) SWIG_fail;
37240 }
37241 }
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37245
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 Py_INCREF(Py_None); resultobj = Py_None;
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj;
37258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37259 PyObject * obj0 = 0 ;
37260 char *kwnames[] = {
37261 (char *) "self", NULL
37262 };
37263
37264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37266 if (SWIG_arg_fail(1)) SWIG_fail;
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 wxMenuItem_ResetOwnerDrawn(arg1);
37270
37271 wxPyEndAllowThreads(__tstate);
37272 if (PyErr_Occurred()) SWIG_fail;
37273 }
37274 Py_INCREF(Py_None); resultobj = Py_None;
37275 return resultobj;
37276 fail:
37277 return NULL;
37278 }
37279
37280
37281 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj;
37283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37284 wxBitmap *arg2 = 0 ;
37285 PyObject * obj0 = 0 ;
37286 PyObject * obj1 = 0 ;
37287 char *kwnames[] = {
37288 (char *) "self",(char *) "bitmap", NULL
37289 };
37290
37291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37293 if (SWIG_arg_fail(1)) SWIG_fail;
37294 {
37295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37296 if (SWIG_arg_fail(2)) SWIG_fail;
37297 if (arg2 == NULL) {
37298 SWIG_null_ref("wxBitmap");
37299 }
37300 if (SWIG_arg_fail(2)) SWIG_fail;
37301 }
37302 {
37303 PyThreadState* __tstate = wxPyBeginAllowThreads();
37304 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37305
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 Py_INCREF(Py_None); resultobj = Py_None;
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37317 PyObject *resultobj;
37318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37319 wxBitmap *result;
37320 PyObject * obj0 = 0 ;
37321 char *kwnames[] = {
37322 (char *) "self", NULL
37323 };
37324
37325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37327 if (SWIG_arg_fail(1)) SWIG_fail;
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 {
37331 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37332 result = (wxBitmap *) &_result_ref;
37333 }
37334
37335 wxPyEndAllowThreads(__tstate);
37336 if (PyErr_Occurred()) SWIG_fail;
37337 }
37338 {
37339 wxBitmap* resultptr = new wxBitmap(*result);
37340 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37341 }
37342 return resultobj;
37343 fail:
37344 return NULL;
37345 }
37346
37347
37348 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37349 PyObject *obj;
37350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37351 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37352 Py_INCREF(obj);
37353 return Py_BuildValue((char *)"");
37354 }
37355 static int _wrap_ControlNameStr_set(PyObject *) {
37356 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37357 return 1;
37358 }
37359
37360
37361 static PyObject *_wrap_ControlNameStr_get(void) {
37362 PyObject *pyobj;
37363
37364 {
37365 #if wxUSE_UNICODE
37366 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37367 #else
37368 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37369 #endif
37370 }
37371 return pyobj;
37372 }
37373
37374
37375 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj;
37377 wxWindow *arg1 = (wxWindow *) 0 ;
37378 int arg2 = (int) -1 ;
37379 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37380 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37381 wxSize const &arg4_defvalue = wxDefaultSize ;
37382 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37383 long arg5 = (long) 0 ;
37384 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37385 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37386 wxString const &arg7_defvalue = wxPyControlNameStr ;
37387 wxString *arg7 = (wxString *) &arg7_defvalue ;
37388 wxControl *result;
37389 wxPoint temp3 ;
37390 wxSize temp4 ;
37391 bool temp7 = false ;
37392 PyObject * obj0 = 0 ;
37393 PyObject * obj1 = 0 ;
37394 PyObject * obj2 = 0 ;
37395 PyObject * obj3 = 0 ;
37396 PyObject * obj4 = 0 ;
37397 PyObject * obj5 = 0 ;
37398 PyObject * obj6 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 if (obj1) {
37407 {
37408 arg2 = (int)(SWIG_As_int(obj1));
37409 if (SWIG_arg_fail(2)) SWIG_fail;
37410 }
37411 }
37412 if (obj2) {
37413 {
37414 arg3 = &temp3;
37415 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37416 }
37417 }
37418 if (obj3) {
37419 {
37420 arg4 = &temp4;
37421 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37422 }
37423 }
37424 if (obj4) {
37425 {
37426 arg5 = (long)(SWIG_As_long(obj4));
37427 if (SWIG_arg_fail(5)) SWIG_fail;
37428 }
37429 }
37430 if (obj5) {
37431 {
37432 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37433 if (SWIG_arg_fail(6)) SWIG_fail;
37434 if (arg6 == NULL) {
37435 SWIG_null_ref("wxValidator");
37436 }
37437 if (SWIG_arg_fail(6)) SWIG_fail;
37438 }
37439 }
37440 if (obj6) {
37441 {
37442 arg7 = wxString_in_helper(obj6);
37443 if (arg7 == NULL) SWIG_fail;
37444 temp7 = true;
37445 }
37446 }
37447 {
37448 if (!wxPyCheckForApp()) SWIG_fail;
37449 PyThreadState* __tstate = wxPyBeginAllowThreads();
37450 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37451
37452 wxPyEndAllowThreads(__tstate);
37453 if (PyErr_Occurred()) SWIG_fail;
37454 }
37455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37456 {
37457 if (temp7)
37458 delete arg7;
37459 }
37460 return resultobj;
37461 fail:
37462 {
37463 if (temp7)
37464 delete arg7;
37465 }
37466 return NULL;
37467 }
37468
37469
37470 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37471 PyObject *resultobj;
37472 wxControl *result;
37473 char *kwnames[] = {
37474 NULL
37475 };
37476
37477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37478 {
37479 if (!wxPyCheckForApp()) SWIG_fail;
37480 PyThreadState* __tstate = wxPyBeginAllowThreads();
37481 result = (wxControl *)new wxControl();
37482
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37487 return resultobj;
37488 fail:
37489 return NULL;
37490 }
37491
37492
37493 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37494 PyObject *resultobj;
37495 wxControl *arg1 = (wxControl *) 0 ;
37496 wxWindow *arg2 = (wxWindow *) 0 ;
37497 int arg3 = (int) -1 ;
37498 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37499 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37500 wxSize const &arg5_defvalue = wxDefaultSize ;
37501 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37502 long arg6 = (long) 0 ;
37503 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37504 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37505 wxString const &arg8_defvalue = wxPyControlNameStr ;
37506 wxString *arg8 = (wxString *) &arg8_defvalue ;
37507 bool result;
37508 wxPoint temp4 ;
37509 wxSize temp5 ;
37510 bool temp8 = false ;
37511 PyObject * obj0 = 0 ;
37512 PyObject * obj1 = 0 ;
37513 PyObject * obj2 = 0 ;
37514 PyObject * obj3 = 0 ;
37515 PyObject * obj4 = 0 ;
37516 PyObject * obj5 = 0 ;
37517 PyObject * obj6 = 0 ;
37518 PyObject * obj7 = 0 ;
37519 char *kwnames[] = {
37520 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37521 };
37522
37523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37525 if (SWIG_arg_fail(1)) SWIG_fail;
37526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37527 if (SWIG_arg_fail(2)) SWIG_fail;
37528 if (obj2) {
37529 {
37530 arg3 = (int)(SWIG_As_int(obj2));
37531 if (SWIG_arg_fail(3)) SWIG_fail;
37532 }
37533 }
37534 if (obj3) {
37535 {
37536 arg4 = &temp4;
37537 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37538 }
37539 }
37540 if (obj4) {
37541 {
37542 arg5 = &temp5;
37543 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37544 }
37545 }
37546 if (obj5) {
37547 {
37548 arg6 = (long)(SWIG_As_long(obj5));
37549 if (SWIG_arg_fail(6)) SWIG_fail;
37550 }
37551 }
37552 if (obj6) {
37553 {
37554 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37555 if (SWIG_arg_fail(7)) SWIG_fail;
37556 if (arg7 == NULL) {
37557 SWIG_null_ref("wxValidator");
37558 }
37559 if (SWIG_arg_fail(7)) SWIG_fail;
37560 }
37561 }
37562 if (obj7) {
37563 {
37564 arg8 = wxString_in_helper(obj7);
37565 if (arg8 == NULL) SWIG_fail;
37566 temp8 = true;
37567 }
37568 }
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37572
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 {
37577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37578 }
37579 {
37580 if (temp8)
37581 delete arg8;
37582 }
37583 return resultobj;
37584 fail:
37585 {
37586 if (temp8)
37587 delete arg8;
37588 }
37589 return NULL;
37590 }
37591
37592
37593 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37594 PyObject *resultobj;
37595 wxControl *arg1 = (wxControl *) 0 ;
37596 wxCommandEvent *arg2 = 0 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char *kwnames[] = {
37600 (char *) "self",(char *) "event", NULL
37601 };
37602
37603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37605 if (SWIG_arg_fail(1)) SWIG_fail;
37606 {
37607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37608 if (SWIG_arg_fail(2)) SWIG_fail;
37609 if (arg2 == NULL) {
37610 SWIG_null_ref("wxCommandEvent");
37611 }
37612 if (SWIG_arg_fail(2)) SWIG_fail;
37613 }
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->Command(*arg2);
37617
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 Py_INCREF(Py_None); resultobj = Py_None;
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37629 PyObject *resultobj;
37630 wxControl *arg1 = (wxControl *) 0 ;
37631 wxString result;
37632 PyObject * obj0 = 0 ;
37633 char *kwnames[] = {
37634 (char *) "self", NULL
37635 };
37636
37637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37639 if (SWIG_arg_fail(1)) SWIG_fail;
37640 {
37641 PyThreadState* __tstate = wxPyBeginAllowThreads();
37642 result = (arg1)->GetLabel();
37643
37644 wxPyEndAllowThreads(__tstate);
37645 if (PyErr_Occurred()) SWIG_fail;
37646 }
37647 {
37648 #if wxUSE_UNICODE
37649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37650 #else
37651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37652 #endif
37653 }
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj;
37662 wxControl *arg1 = (wxControl *) 0 ;
37663 wxString *arg2 = 0 ;
37664 bool temp2 = false ;
37665 PyObject * obj0 = 0 ;
37666 PyObject * obj1 = 0 ;
37667 char *kwnames[] = {
37668 (char *) "self",(char *) "label", NULL
37669 };
37670
37671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37673 if (SWIG_arg_fail(1)) SWIG_fail;
37674 {
37675 arg2 = wxString_in_helper(obj1);
37676 if (arg2 == NULL) SWIG_fail;
37677 temp2 = true;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->SetLabel((wxString const &)*arg2);
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 Py_INCREF(Py_None); resultobj = Py_None;
37687 {
37688 if (temp2)
37689 delete arg2;
37690 }
37691 return resultobj;
37692 fail:
37693 {
37694 if (temp2)
37695 delete arg2;
37696 }
37697 return NULL;
37698 }
37699
37700
37701 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37702 PyObject *resultobj;
37703 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37704 wxVisualAttributes result;
37705 PyObject * obj0 = 0 ;
37706 char *kwnames[] = {
37707 (char *) "variant", NULL
37708 };
37709
37710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37711 if (obj0) {
37712 {
37713 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37714 if (SWIG_arg_fail(1)) SWIG_fail;
37715 }
37716 }
37717 {
37718 if (!wxPyCheckForApp()) SWIG_fail;
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 {
37726 wxVisualAttributes * resultptr;
37727 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37729 }
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37737 PyObject *obj;
37738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37739 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37740 Py_INCREF(obj);
37741 return Py_BuildValue((char *)"");
37742 }
37743 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj;
37745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37746 wxString *arg2 = 0 ;
37747 PyObject *arg3 = (PyObject *) NULL ;
37748 int result;
37749 bool temp2 = false ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 PyObject * obj2 = 0 ;
37753 char *kwnames[] = {
37754 (char *) "self",(char *) "item",(char *) "clientData", NULL
37755 };
37756
37757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37759 if (SWIG_arg_fail(1)) SWIG_fail;
37760 {
37761 arg2 = wxString_in_helper(obj1);
37762 if (arg2 == NULL) SWIG_fail;
37763 temp2 = true;
37764 }
37765 if (obj2) {
37766 arg3 = obj2;
37767 }
37768 {
37769 PyThreadState* __tstate = wxPyBeginAllowThreads();
37770 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37771
37772 wxPyEndAllowThreads(__tstate);
37773 if (PyErr_Occurred()) SWIG_fail;
37774 }
37775 {
37776 resultobj = SWIG_From_int((int)(result));
37777 }
37778 {
37779 if (temp2)
37780 delete arg2;
37781 }
37782 return resultobj;
37783 fail:
37784 {
37785 if (temp2)
37786 delete arg2;
37787 }
37788 return NULL;
37789 }
37790
37791
37792 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37793 PyObject *resultobj;
37794 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37795 wxArrayString *arg2 = 0 ;
37796 bool temp2 = false ;
37797 PyObject * obj0 = 0 ;
37798 PyObject * obj1 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self",(char *) "strings", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 if (! PySequence_Check(obj1)) {
37808 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37809 SWIG_fail;
37810 }
37811 arg2 = new wxArrayString;
37812 temp2 = true;
37813 int i, len=PySequence_Length(obj1);
37814 for (i=0; i<len; i++) {
37815 PyObject* item = PySequence_GetItem(obj1, i);
37816 wxString* s = wxString_in_helper(item);
37817 if (PyErr_Occurred()) SWIG_fail;
37818 arg2->Add(*s);
37819 delete s;
37820 Py_DECREF(item);
37821 }
37822 }
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 (arg1)->Append((wxArrayString const &)*arg2);
37826
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 Py_INCREF(Py_None); resultobj = Py_None;
37831 {
37832 if (temp2) delete arg2;
37833 }
37834 return resultobj;
37835 fail:
37836 {
37837 if (temp2) delete arg2;
37838 }
37839 return NULL;
37840 }
37841
37842
37843 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37844 PyObject *resultobj;
37845 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37846 wxString *arg2 = 0 ;
37847 int arg3 ;
37848 PyObject *arg4 = (PyObject *) NULL ;
37849 int result;
37850 bool temp2 = false ;
37851 PyObject * obj0 = 0 ;
37852 PyObject * obj1 = 0 ;
37853 PyObject * obj2 = 0 ;
37854 PyObject * obj3 = 0 ;
37855 char *kwnames[] = {
37856 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37857 };
37858
37859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37861 if (SWIG_arg_fail(1)) SWIG_fail;
37862 {
37863 arg2 = wxString_in_helper(obj1);
37864 if (arg2 == NULL) SWIG_fail;
37865 temp2 = true;
37866 }
37867 {
37868 arg3 = (int)(SWIG_As_int(obj2));
37869 if (SWIG_arg_fail(3)) SWIG_fail;
37870 }
37871 if (obj3) {
37872 arg4 = obj3;
37873 }
37874 {
37875 PyThreadState* __tstate = wxPyBeginAllowThreads();
37876 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37877
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 resultobj = SWIG_From_int((int)(result));
37883 }
37884 {
37885 if (temp2)
37886 delete arg2;
37887 }
37888 return resultobj;
37889 fail:
37890 {
37891 if (temp2)
37892 delete arg2;
37893 }
37894 return NULL;
37895 }
37896
37897
37898 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37899 PyObject *resultobj;
37900 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37901 PyObject * obj0 = 0 ;
37902 char *kwnames[] = {
37903 (char *) "self", NULL
37904 };
37905
37906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37908 if (SWIG_arg_fail(1)) SWIG_fail;
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 (arg1)->Clear();
37912
37913 wxPyEndAllowThreads(__tstate);
37914 if (PyErr_Occurred()) SWIG_fail;
37915 }
37916 Py_INCREF(Py_None); resultobj = Py_None;
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37924 PyObject *resultobj;
37925 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37926 int arg2 ;
37927 PyObject * obj0 = 0 ;
37928 PyObject * obj1 = 0 ;
37929 char *kwnames[] = {
37930 (char *) "self",(char *) "n", NULL
37931 };
37932
37933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37935 if (SWIG_arg_fail(1)) SWIG_fail;
37936 {
37937 arg2 = (int)(SWIG_As_int(obj1));
37938 if (SWIG_arg_fail(2)) SWIG_fail;
37939 }
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 (arg1)->Delete(arg2);
37943
37944 wxPyEndAllowThreads(__tstate);
37945 if (PyErr_Occurred()) SWIG_fail;
37946 }
37947 Py_INCREF(Py_None); resultobj = Py_None;
37948 return resultobj;
37949 fail:
37950 return NULL;
37951 }
37952
37953
37954 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37955 PyObject *resultobj;
37956 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37957 int arg2 ;
37958 PyObject *result;
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_GetClientData",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 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37975
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = result;
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37987 PyObject *resultobj;
37988 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37989 int arg2 ;
37990 PyObject *arg3 = (PyObject *) 0 ;
37991 PyObject * obj0 = 0 ;
37992 PyObject * obj1 = 0 ;
37993 PyObject * obj2 = 0 ;
37994 char *kwnames[] = {
37995 (char *) "self",(char *) "n",(char *) "clientData", NULL
37996 };
37997
37998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38000 if (SWIG_arg_fail(1)) SWIG_fail;
38001 {
38002 arg2 = (int)(SWIG_As_int(obj1));
38003 if (SWIG_arg_fail(2)) SWIG_fail;
38004 }
38005 arg3 = obj2;
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 wxItemContainer_SetClientData(arg1,arg2,arg3);
38009
38010 wxPyEndAllowThreads(__tstate);
38011 if (PyErr_Occurred()) SWIG_fail;
38012 }
38013 Py_INCREF(Py_None); resultobj = Py_None;
38014 return resultobj;
38015 fail:
38016 return NULL;
38017 }
38018
38019
38020 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38021 PyObject *resultobj;
38022 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38023 int result;
38024 PyObject * obj0 = 0 ;
38025 char *kwnames[] = {
38026 (char *) "self", NULL
38027 };
38028
38029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38031 if (SWIG_arg_fail(1)) SWIG_fail;
38032 {
38033 PyThreadState* __tstate = wxPyBeginAllowThreads();
38034 result = (int)((wxItemContainer const *)arg1)->GetCount();
38035
38036 wxPyEndAllowThreads(__tstate);
38037 if (PyErr_Occurred()) SWIG_fail;
38038 }
38039 {
38040 resultobj = SWIG_From_int((int)(result));
38041 }
38042 return resultobj;
38043 fail:
38044 return NULL;
38045 }
38046
38047
38048 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38049 PyObject *resultobj;
38050 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38051 bool result;
38052 PyObject * obj0 = 0 ;
38053 char *kwnames[] = {
38054 (char *) "self", NULL
38055 };
38056
38057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38059 if (SWIG_arg_fail(1)) SWIG_fail;
38060 {
38061 PyThreadState* __tstate = wxPyBeginAllowThreads();
38062 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38063
38064 wxPyEndAllowThreads(__tstate);
38065 if (PyErr_Occurred()) SWIG_fail;
38066 }
38067 {
38068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38069 }
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj;
38078 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38079 int arg2 ;
38080 wxString result;
38081 PyObject * obj0 = 0 ;
38082 PyObject * obj1 = 0 ;
38083 char *kwnames[] = {
38084 (char *) "self",(char *) "n", NULL
38085 };
38086
38087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38089 if (SWIG_arg_fail(1)) SWIG_fail;
38090 {
38091 arg2 = (int)(SWIG_As_int(obj1));
38092 if (SWIG_arg_fail(2)) SWIG_fail;
38093 }
38094 {
38095 PyThreadState* __tstate = wxPyBeginAllowThreads();
38096 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38097
38098 wxPyEndAllowThreads(__tstate);
38099 if (PyErr_Occurred()) SWIG_fail;
38100 }
38101 {
38102 #if wxUSE_UNICODE
38103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38104 #else
38105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38106 #endif
38107 }
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38115 PyObject *resultobj;
38116 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38117 wxArrayString result;
38118 PyObject * obj0 = 0 ;
38119 char *kwnames[] = {
38120 (char *) "self", NULL
38121 };
38122
38123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38125 if (SWIG_arg_fail(1)) SWIG_fail;
38126 {
38127 PyThreadState* __tstate = wxPyBeginAllowThreads();
38128 result = ((wxItemContainer const *)arg1)->GetStrings();
38129
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 {
38134 resultobj = wxArrayString2PyList_helper(result);
38135 }
38136 return resultobj;
38137 fail:
38138 return NULL;
38139 }
38140
38141
38142 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38143 PyObject *resultobj;
38144 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38145 int arg2 ;
38146 wxString *arg3 = 0 ;
38147 bool temp3 = false ;
38148 PyObject * obj0 = 0 ;
38149 PyObject * obj1 = 0 ;
38150 PyObject * obj2 = 0 ;
38151 char *kwnames[] = {
38152 (char *) "self",(char *) "n",(char *) "s", NULL
38153 };
38154
38155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
38160 if (SWIG_arg_fail(2)) SWIG_fail;
38161 }
38162 {
38163 arg3 = wxString_in_helper(obj2);
38164 if (arg3 == NULL) SWIG_fail;
38165 temp3 = true;
38166 }
38167 {
38168 PyThreadState* __tstate = wxPyBeginAllowThreads();
38169 (arg1)->SetString(arg2,(wxString const &)*arg3);
38170
38171 wxPyEndAllowThreads(__tstate);
38172 if (PyErr_Occurred()) SWIG_fail;
38173 }
38174 Py_INCREF(Py_None); resultobj = Py_None;
38175 {
38176 if (temp3)
38177 delete arg3;
38178 }
38179 return resultobj;
38180 fail:
38181 {
38182 if (temp3)
38183 delete arg3;
38184 }
38185 return NULL;
38186 }
38187
38188
38189 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38190 PyObject *resultobj;
38191 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38192 wxString *arg2 = 0 ;
38193 int result;
38194 bool temp2 = false ;
38195 PyObject * obj0 = 0 ;
38196 PyObject * obj1 = 0 ;
38197 char *kwnames[] = {
38198 (char *) "self",(char *) "s", NULL
38199 };
38200
38201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38203 if (SWIG_arg_fail(1)) SWIG_fail;
38204 {
38205 arg2 = wxString_in_helper(obj1);
38206 if (arg2 == NULL) SWIG_fail;
38207 temp2 = true;
38208 }
38209 {
38210 PyThreadState* __tstate = wxPyBeginAllowThreads();
38211 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38212
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 {
38217 resultobj = SWIG_From_int((int)(result));
38218 }
38219 {
38220 if (temp2)
38221 delete arg2;
38222 }
38223 return resultobj;
38224 fail:
38225 {
38226 if (temp2)
38227 delete arg2;
38228 }
38229 return NULL;
38230 }
38231
38232
38233 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj;
38235 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38236 int arg2 ;
38237 PyObject * obj0 = 0 ;
38238 PyObject * obj1 = 0 ;
38239 char *kwnames[] = {
38240 (char *) "self",(char *) "n", NULL
38241 };
38242
38243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38245 if (SWIG_arg_fail(1)) SWIG_fail;
38246 {
38247 arg2 = (int)(SWIG_As_int(obj1));
38248 if (SWIG_arg_fail(2)) SWIG_fail;
38249 }
38250 {
38251 PyThreadState* __tstate = wxPyBeginAllowThreads();
38252 (arg1)->SetSelection(arg2);
38253
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 Py_INCREF(Py_None); resultobj = Py_None;
38258 return resultobj;
38259 fail:
38260 return NULL;
38261 }
38262
38263
38264 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38265 PyObject *resultobj;
38266 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38267 int result;
38268 PyObject * obj0 = 0 ;
38269 char *kwnames[] = {
38270 (char *) "self", NULL
38271 };
38272
38273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38275 if (SWIG_arg_fail(1)) SWIG_fail;
38276 {
38277 PyThreadState* __tstate = wxPyBeginAllowThreads();
38278 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38279
38280 wxPyEndAllowThreads(__tstate);
38281 if (PyErr_Occurred()) SWIG_fail;
38282 }
38283 {
38284 resultobj = SWIG_From_int((int)(result));
38285 }
38286 return resultobj;
38287 fail:
38288 return NULL;
38289 }
38290
38291
38292 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38293 PyObject *resultobj;
38294 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38295 wxString *arg2 = 0 ;
38296 bool result;
38297 bool temp2 = false ;
38298 PyObject * obj0 = 0 ;
38299 PyObject * obj1 = 0 ;
38300 char *kwnames[] = {
38301 (char *) "self",(char *) "s", NULL
38302 };
38303
38304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38306 if (SWIG_arg_fail(1)) SWIG_fail;
38307 {
38308 arg2 = wxString_in_helper(obj1);
38309 if (arg2 == NULL) SWIG_fail;
38310 temp2 = true;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38315
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 {
38320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38321 }
38322 {
38323 if (temp2)
38324 delete arg2;
38325 }
38326 return resultobj;
38327 fail:
38328 {
38329 if (temp2)
38330 delete arg2;
38331 }
38332 return NULL;
38333 }
38334
38335
38336 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38337 PyObject *resultobj;
38338 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38339 wxString result;
38340 PyObject * obj0 = 0 ;
38341 char *kwnames[] = {
38342 (char *) "self", NULL
38343 };
38344
38345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38347 if (SWIG_arg_fail(1)) SWIG_fail;
38348 {
38349 PyThreadState* __tstate = wxPyBeginAllowThreads();
38350 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38351
38352 wxPyEndAllowThreads(__tstate);
38353 if (PyErr_Occurred()) SWIG_fail;
38354 }
38355 {
38356 #if wxUSE_UNICODE
38357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38358 #else
38359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38360 #endif
38361 }
38362 return resultobj;
38363 fail:
38364 return NULL;
38365 }
38366
38367
38368 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38369 PyObject *resultobj;
38370 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38371 int arg2 ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 char *kwnames[] = {
38375 (char *) "self",(char *) "n", NULL
38376 };
38377
38378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38380 if (SWIG_arg_fail(1)) SWIG_fail;
38381 {
38382 arg2 = (int)(SWIG_As_int(obj1));
38383 if (SWIG_arg_fail(2)) SWIG_fail;
38384 }
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 (arg1)->Select(arg2);
38388
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 Py_INCREF(Py_None); resultobj = Py_None;
38393 return resultobj;
38394 fail:
38395 return NULL;
38396 }
38397
38398
38399 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38400 PyObject *obj;
38401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38402 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38403 Py_INCREF(obj);
38404 return Py_BuildValue((char *)"");
38405 }
38406 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38407 PyObject *obj;
38408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38409 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38410 Py_INCREF(obj);
38411 return Py_BuildValue((char *)"");
38412 }
38413 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38414 PyObject *resultobj;
38415 wxSizerItem *result;
38416 char *kwnames[] = {
38417 NULL
38418 };
38419
38420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38421 {
38422 PyThreadState* __tstate = wxPyBeginAllowThreads();
38423 result = (wxSizerItem *)new wxSizerItem();
38424
38425 wxPyEndAllowThreads(__tstate);
38426 if (PyErr_Occurred()) SWIG_fail;
38427 }
38428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38429 return resultobj;
38430 fail:
38431 return NULL;
38432 }
38433
38434
38435 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38436 PyObject *resultobj;
38437 wxWindow *arg1 = (wxWindow *) 0 ;
38438 int arg2 ;
38439 int arg3 ;
38440 int arg4 ;
38441 PyObject *arg5 = (PyObject *) NULL ;
38442 wxSizerItem *result;
38443 PyObject * obj0 = 0 ;
38444 PyObject * obj1 = 0 ;
38445 PyObject * obj2 = 0 ;
38446 PyObject * obj3 = 0 ;
38447 PyObject * obj4 = 0 ;
38448 char *kwnames[] = {
38449 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38450 };
38451
38452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38454 if (SWIG_arg_fail(1)) SWIG_fail;
38455 {
38456 arg2 = (int)(SWIG_As_int(obj1));
38457 if (SWIG_arg_fail(2)) SWIG_fail;
38458 }
38459 {
38460 arg3 = (int)(SWIG_As_int(obj2));
38461 if (SWIG_arg_fail(3)) SWIG_fail;
38462 }
38463 {
38464 arg4 = (int)(SWIG_As_int(obj3));
38465 if (SWIG_arg_fail(4)) SWIG_fail;
38466 }
38467 if (obj4) {
38468 arg5 = obj4;
38469 }
38470 {
38471 PyThreadState* __tstate = wxPyBeginAllowThreads();
38472 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38473
38474 wxPyEndAllowThreads(__tstate);
38475 if (PyErr_Occurred()) SWIG_fail;
38476 }
38477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38478 return resultobj;
38479 fail:
38480 return NULL;
38481 }
38482
38483
38484 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38485 PyObject *resultobj;
38486 int arg1 ;
38487 int arg2 ;
38488 int arg3 ;
38489 int arg4 ;
38490 int arg5 ;
38491 PyObject *arg6 = (PyObject *) NULL ;
38492 wxSizerItem *result;
38493 PyObject * obj0 = 0 ;
38494 PyObject * obj1 = 0 ;
38495 PyObject * obj2 = 0 ;
38496 PyObject * obj3 = 0 ;
38497 PyObject * obj4 = 0 ;
38498 PyObject * obj5 = 0 ;
38499 char *kwnames[] = {
38500 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38501 };
38502
38503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38504 {
38505 arg1 = (int)(SWIG_As_int(obj0));
38506 if (SWIG_arg_fail(1)) SWIG_fail;
38507 }
38508 {
38509 arg2 = (int)(SWIG_As_int(obj1));
38510 if (SWIG_arg_fail(2)) SWIG_fail;
38511 }
38512 {
38513 arg3 = (int)(SWIG_As_int(obj2));
38514 if (SWIG_arg_fail(3)) SWIG_fail;
38515 }
38516 {
38517 arg4 = (int)(SWIG_As_int(obj3));
38518 if (SWIG_arg_fail(4)) SWIG_fail;
38519 }
38520 {
38521 arg5 = (int)(SWIG_As_int(obj4));
38522 if (SWIG_arg_fail(5)) SWIG_fail;
38523 }
38524 if (obj5) {
38525 arg6 = obj5;
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38530
38531 wxPyEndAllowThreads(__tstate);
38532 if (PyErr_Occurred()) SWIG_fail;
38533 }
38534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38535 return resultobj;
38536 fail:
38537 return NULL;
38538 }
38539
38540
38541 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38542 PyObject *resultobj;
38543 wxSizer *arg1 = (wxSizer *) 0 ;
38544 int arg2 ;
38545 int arg3 ;
38546 int arg4 ;
38547 PyObject *arg5 = (PyObject *) NULL ;
38548 wxSizerItem *result;
38549 PyObject * obj0 = 0 ;
38550 PyObject * obj1 = 0 ;
38551 PyObject * obj2 = 0 ;
38552 PyObject * obj3 = 0 ;
38553 PyObject * obj4 = 0 ;
38554 char *kwnames[] = {
38555 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38556 };
38557
38558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38560 if (SWIG_arg_fail(1)) SWIG_fail;
38561 {
38562 arg2 = (int)(SWIG_As_int(obj1));
38563 if (SWIG_arg_fail(2)) SWIG_fail;
38564 }
38565 {
38566 arg3 = (int)(SWIG_As_int(obj2));
38567 if (SWIG_arg_fail(3)) SWIG_fail;
38568 }
38569 {
38570 arg4 = (int)(SWIG_As_int(obj3));
38571 if (SWIG_arg_fail(4)) SWIG_fail;
38572 }
38573 if (obj4) {
38574 arg5 = obj4;
38575 }
38576 {
38577 PyThreadState* __tstate = wxPyBeginAllowThreads();
38578 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38579
38580 wxPyEndAllowThreads(__tstate);
38581 if (PyErr_Occurred()) SWIG_fail;
38582 }
38583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38584 return resultobj;
38585 fail:
38586 return NULL;
38587 }
38588
38589
38590 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38591 PyObject *resultobj;
38592 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38593 PyObject * obj0 = 0 ;
38594 char *kwnames[] = {
38595 (char *) "self", NULL
38596 };
38597
38598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38600 if (SWIG_arg_fail(1)) SWIG_fail;
38601 {
38602 PyThreadState* __tstate = wxPyBeginAllowThreads();
38603 (arg1)->DeleteWindows();
38604
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 Py_INCREF(Py_None); resultobj = Py_None;
38609 return resultobj;
38610 fail:
38611 return NULL;
38612 }
38613
38614
38615 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38616 PyObject *resultobj;
38617 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38618 PyObject * obj0 = 0 ;
38619 char *kwnames[] = {
38620 (char *) "self", NULL
38621 };
38622
38623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38625 if (SWIG_arg_fail(1)) SWIG_fail;
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 (arg1)->DetachSizer();
38629
38630 wxPyEndAllowThreads(__tstate);
38631 if (PyErr_Occurred()) SWIG_fail;
38632 }
38633 Py_INCREF(Py_None); resultobj = Py_None;
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj;
38642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38643 wxSize result;
38644 PyObject * obj0 = 0 ;
38645 char *kwnames[] = {
38646 (char *) "self", NULL
38647 };
38648
38649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38651 if (SWIG_arg_fail(1)) SWIG_fail;
38652 {
38653 PyThreadState* __tstate = wxPyBeginAllowThreads();
38654 result = (arg1)->GetSize();
38655
38656 wxPyEndAllowThreads(__tstate);
38657 if (PyErr_Occurred()) SWIG_fail;
38658 }
38659 {
38660 wxSize * resultptr;
38661 resultptr = new wxSize((wxSize &)(result));
38662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38663 }
38664 return resultobj;
38665 fail:
38666 return NULL;
38667 }
38668
38669
38670 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38671 PyObject *resultobj;
38672 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38673 wxSize result;
38674 PyObject * obj0 = 0 ;
38675 char *kwnames[] = {
38676 (char *) "self", NULL
38677 };
38678
38679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38681 if (SWIG_arg_fail(1)) SWIG_fail;
38682 {
38683 PyThreadState* __tstate = wxPyBeginAllowThreads();
38684 result = (arg1)->CalcMin();
38685
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 {
38690 wxSize * resultptr;
38691 resultptr = new wxSize((wxSize &)(result));
38692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38693 }
38694 return resultobj;
38695 fail:
38696 return NULL;
38697 }
38698
38699
38700 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38701 PyObject *resultobj;
38702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38703 wxPoint arg2 ;
38704 wxSize arg3 ;
38705 PyObject * obj0 = 0 ;
38706 PyObject * obj1 = 0 ;
38707 PyObject * obj2 = 0 ;
38708 char *kwnames[] = {
38709 (char *) "self",(char *) "pos",(char *) "size", NULL
38710 };
38711
38712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38714 if (SWIG_arg_fail(1)) SWIG_fail;
38715 {
38716 wxPoint * argp;
38717 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38718 if (SWIG_arg_fail(2)) SWIG_fail;
38719 if (argp == NULL) {
38720 SWIG_null_ref("wxPoint");
38721 }
38722 if (SWIG_arg_fail(2)) SWIG_fail;
38723 arg2 = *argp;
38724 }
38725 {
38726 wxSize * argp;
38727 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38728 if (SWIG_arg_fail(3)) SWIG_fail;
38729 if (argp == NULL) {
38730 SWIG_null_ref("wxSize");
38731 }
38732 if (SWIG_arg_fail(3)) SWIG_fail;
38733 arg3 = *argp;
38734 }
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 (arg1)->SetDimension(arg2,arg3);
38738
38739 wxPyEndAllowThreads(__tstate);
38740 if (PyErr_Occurred()) SWIG_fail;
38741 }
38742 Py_INCREF(Py_None); resultobj = Py_None;
38743 return resultobj;
38744 fail:
38745 return NULL;
38746 }
38747
38748
38749 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38750 PyObject *resultobj;
38751 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38752 wxSize result;
38753 PyObject * obj0 = 0 ;
38754 char *kwnames[] = {
38755 (char *) "self", NULL
38756 };
38757
38758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38760 if (SWIG_arg_fail(1)) SWIG_fail;
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 result = (arg1)->GetMinSize();
38764
38765 wxPyEndAllowThreads(__tstate);
38766 if (PyErr_Occurred()) SWIG_fail;
38767 }
38768 {
38769 wxSize * resultptr;
38770 resultptr = new wxSize((wxSize &)(result));
38771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38772 }
38773 return resultobj;
38774 fail:
38775 return NULL;
38776 }
38777
38778
38779 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38780 PyObject *resultobj;
38781 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38782 wxSize result;
38783 PyObject * obj0 = 0 ;
38784 char *kwnames[] = {
38785 (char *) "self", NULL
38786 };
38787
38788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38790 if (SWIG_arg_fail(1)) SWIG_fail;
38791 {
38792 PyThreadState* __tstate = wxPyBeginAllowThreads();
38793 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38794
38795 wxPyEndAllowThreads(__tstate);
38796 if (PyErr_Occurred()) SWIG_fail;
38797 }
38798 {
38799 wxSize * resultptr;
38800 resultptr = new wxSize((wxSize &)(result));
38801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38802 }
38803 return resultobj;
38804 fail:
38805 return NULL;
38806 }
38807
38808
38809 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38810 PyObject *resultobj;
38811 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38812 int arg2 ;
38813 int arg3 ;
38814 PyObject * obj0 = 0 ;
38815 PyObject * obj1 = 0 ;
38816 PyObject * obj2 = 0 ;
38817 char *kwnames[] = {
38818 (char *) "self",(char *) "x",(char *) "y", NULL
38819 };
38820
38821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38823 if (SWIG_arg_fail(1)) SWIG_fail;
38824 {
38825 arg2 = (int)(SWIG_As_int(obj1));
38826 if (SWIG_arg_fail(2)) SWIG_fail;
38827 }
38828 {
38829 arg3 = (int)(SWIG_As_int(obj2));
38830 if (SWIG_arg_fail(3)) SWIG_fail;
38831 }
38832 {
38833 PyThreadState* __tstate = wxPyBeginAllowThreads();
38834 (arg1)->SetInitSize(arg2,arg3);
38835
38836 wxPyEndAllowThreads(__tstate);
38837 if (PyErr_Occurred()) SWIG_fail;
38838 }
38839 Py_INCREF(Py_None); resultobj = Py_None;
38840 return resultobj;
38841 fail:
38842 return NULL;
38843 }
38844
38845
38846 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38847 PyObject *resultobj;
38848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38849 int arg2 ;
38850 int arg3 ;
38851 PyObject * obj0 = 0 ;
38852 PyObject * obj1 = 0 ;
38853 PyObject * obj2 = 0 ;
38854 char *kwnames[] = {
38855 (char *) "self",(char *) "width",(char *) "height", NULL
38856 };
38857
38858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38860 if (SWIG_arg_fail(1)) SWIG_fail;
38861 {
38862 arg2 = (int)(SWIG_As_int(obj1));
38863 if (SWIG_arg_fail(2)) SWIG_fail;
38864 }
38865 {
38866 arg3 = (int)(SWIG_As_int(obj2));
38867 if (SWIG_arg_fail(3)) SWIG_fail;
38868 }
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 (arg1)->SetRatio(arg2,arg3);
38872
38873 wxPyEndAllowThreads(__tstate);
38874 if (PyErr_Occurred()) SWIG_fail;
38875 }
38876 Py_INCREF(Py_None); resultobj = Py_None;
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38884 PyObject *resultobj;
38885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38886 wxSize *arg2 = 0 ;
38887 wxSize temp2 ;
38888 PyObject * obj0 = 0 ;
38889 PyObject * obj1 = 0 ;
38890 char *kwnames[] = {
38891 (char *) "self",(char *) "size", NULL
38892 };
38893
38894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38896 if (SWIG_arg_fail(1)) SWIG_fail;
38897 {
38898 arg2 = &temp2;
38899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38900 }
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 (arg1)->SetRatio((wxSize const &)*arg2);
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_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38916 PyObject *resultobj;
38917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38918 float arg2 ;
38919 PyObject * obj0 = 0 ;
38920 PyObject * obj1 = 0 ;
38921 char *kwnames[] = {
38922 (char *) "self",(char *) "ratio", NULL
38923 };
38924
38925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38927 if (SWIG_arg_fail(1)) SWIG_fail;
38928 {
38929 arg2 = (float)(SWIG_As_float(obj1));
38930 if (SWIG_arg_fail(2)) SWIG_fail;
38931 }
38932 {
38933 PyThreadState* __tstate = wxPyBeginAllowThreads();
38934 (arg1)->SetRatio(arg2);
38935
38936 wxPyEndAllowThreads(__tstate);
38937 if (PyErr_Occurred()) SWIG_fail;
38938 }
38939 Py_INCREF(Py_None); resultobj = Py_None;
38940 return resultobj;
38941 fail:
38942 return NULL;
38943 }
38944
38945
38946 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38947 PyObject *resultobj;
38948 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38949 float result;
38950 PyObject * obj0 = 0 ;
38951 char *kwnames[] = {
38952 (char *) "self", NULL
38953 };
38954
38955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38957 if (SWIG_arg_fail(1)) SWIG_fail;
38958 {
38959 PyThreadState* __tstate = wxPyBeginAllowThreads();
38960 result = (float)(arg1)->GetRatio();
38961
38962 wxPyEndAllowThreads(__tstate);
38963 if (PyErr_Occurred()) SWIG_fail;
38964 }
38965 {
38966 resultobj = SWIG_From_float((float)(result));
38967 }
38968 return resultobj;
38969 fail:
38970 return NULL;
38971 }
38972
38973
38974 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38975 PyObject *resultobj;
38976 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38977 wxRect result;
38978 PyObject * obj0 = 0 ;
38979 char *kwnames[] = {
38980 (char *) "self", NULL
38981 };
38982
38983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38985 if (SWIG_arg_fail(1)) SWIG_fail;
38986 {
38987 PyThreadState* __tstate = wxPyBeginAllowThreads();
38988 result = (arg1)->GetRect();
38989
38990 wxPyEndAllowThreads(__tstate);
38991 if (PyErr_Occurred()) SWIG_fail;
38992 }
38993 {
38994 wxRect * resultptr;
38995 resultptr = new wxRect((wxRect &)(result));
38996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38997 }
38998 return resultobj;
38999 fail:
39000 return NULL;
39001 }
39002
39003
39004 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39005 PyObject *resultobj;
39006 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39007 bool result;
39008 PyObject * obj0 = 0 ;
39009 char *kwnames[] = {
39010 (char *) "self", NULL
39011 };
39012
39013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39015 if (SWIG_arg_fail(1)) SWIG_fail;
39016 {
39017 PyThreadState* __tstate = wxPyBeginAllowThreads();
39018 result = (bool)(arg1)->IsWindow();
39019
39020 wxPyEndAllowThreads(__tstate);
39021 if (PyErr_Occurred()) SWIG_fail;
39022 }
39023 {
39024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39025 }
39026 return resultobj;
39027 fail:
39028 return NULL;
39029 }
39030
39031
39032 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39033 PyObject *resultobj;
39034 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39035 bool result;
39036 PyObject * obj0 = 0 ;
39037 char *kwnames[] = {
39038 (char *) "self", NULL
39039 };
39040
39041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39043 if (SWIG_arg_fail(1)) SWIG_fail;
39044 {
39045 PyThreadState* __tstate = wxPyBeginAllowThreads();
39046 result = (bool)(arg1)->IsSizer();
39047
39048 wxPyEndAllowThreads(__tstate);
39049 if (PyErr_Occurred()) SWIG_fail;
39050 }
39051 {
39052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39053 }
39054 return resultobj;
39055 fail:
39056 return NULL;
39057 }
39058
39059
39060 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj;
39062 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39063 bool result;
39064 PyObject * obj0 = 0 ;
39065 char *kwnames[] = {
39066 (char *) "self", NULL
39067 };
39068
39069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39071 if (SWIG_arg_fail(1)) SWIG_fail;
39072 {
39073 PyThreadState* __tstate = wxPyBeginAllowThreads();
39074 result = (bool)(arg1)->IsSpacer();
39075
39076 wxPyEndAllowThreads(__tstate);
39077 if (PyErr_Occurred()) SWIG_fail;
39078 }
39079 {
39080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39081 }
39082 return resultobj;
39083 fail:
39084 return NULL;
39085 }
39086
39087
39088 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39089 PyObject *resultobj;
39090 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39091 int arg2 ;
39092 PyObject * obj0 = 0 ;
39093 PyObject * obj1 = 0 ;
39094 char *kwnames[] = {
39095 (char *) "self",(char *) "proportion", NULL
39096 };
39097
39098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39100 if (SWIG_arg_fail(1)) SWIG_fail;
39101 {
39102 arg2 = (int)(SWIG_As_int(obj1));
39103 if (SWIG_arg_fail(2)) SWIG_fail;
39104 }
39105 {
39106 PyThreadState* __tstate = wxPyBeginAllowThreads();
39107 (arg1)->SetProportion(arg2);
39108
39109 wxPyEndAllowThreads(__tstate);
39110 if (PyErr_Occurred()) SWIG_fail;
39111 }
39112 Py_INCREF(Py_None); resultobj = Py_None;
39113 return resultobj;
39114 fail:
39115 return NULL;
39116 }
39117
39118
39119 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39120 PyObject *resultobj;
39121 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39122 int result;
39123 PyObject * obj0 = 0 ;
39124 char *kwnames[] = {
39125 (char *) "self", NULL
39126 };
39127
39128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39130 if (SWIG_arg_fail(1)) SWIG_fail;
39131 {
39132 PyThreadState* __tstate = wxPyBeginAllowThreads();
39133 result = (int)(arg1)->GetProportion();
39134
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 {
39139 resultobj = SWIG_From_int((int)(result));
39140 }
39141 return resultobj;
39142 fail:
39143 return NULL;
39144 }
39145
39146
39147 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj;
39149 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39150 int arg2 ;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 char *kwnames[] = {
39154 (char *) "self",(char *) "flag", NULL
39155 };
39156
39157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39159 if (SWIG_arg_fail(1)) SWIG_fail;
39160 {
39161 arg2 = (int)(SWIG_As_int(obj1));
39162 if (SWIG_arg_fail(2)) SWIG_fail;
39163 }
39164 {
39165 PyThreadState* __tstate = wxPyBeginAllowThreads();
39166 (arg1)->SetFlag(arg2);
39167
39168 wxPyEndAllowThreads(__tstate);
39169 if (PyErr_Occurred()) SWIG_fail;
39170 }
39171 Py_INCREF(Py_None); resultobj = Py_None;
39172 return resultobj;
39173 fail:
39174 return NULL;
39175 }
39176
39177
39178 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39179 PyObject *resultobj;
39180 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39181 int result;
39182 PyObject * obj0 = 0 ;
39183 char *kwnames[] = {
39184 (char *) "self", NULL
39185 };
39186
39187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39189 if (SWIG_arg_fail(1)) SWIG_fail;
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 result = (int)(arg1)->GetFlag();
39193
39194 wxPyEndAllowThreads(__tstate);
39195 if (PyErr_Occurred()) SWIG_fail;
39196 }
39197 {
39198 resultobj = SWIG_From_int((int)(result));
39199 }
39200 return resultobj;
39201 fail:
39202 return NULL;
39203 }
39204
39205
39206 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39207 PyObject *resultobj;
39208 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39209 int arg2 ;
39210 PyObject * obj0 = 0 ;
39211 PyObject * obj1 = 0 ;
39212 char *kwnames[] = {
39213 (char *) "self",(char *) "border", NULL
39214 };
39215
39216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39218 if (SWIG_arg_fail(1)) SWIG_fail;
39219 {
39220 arg2 = (int)(SWIG_As_int(obj1));
39221 if (SWIG_arg_fail(2)) SWIG_fail;
39222 }
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 (arg1)->SetBorder(arg2);
39226
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 Py_INCREF(Py_None); resultobj = Py_None;
39231 return resultobj;
39232 fail:
39233 return NULL;
39234 }
39235
39236
39237 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj;
39239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39240 int result;
39241 PyObject * obj0 = 0 ;
39242 char *kwnames[] = {
39243 (char *) "self", NULL
39244 };
39245
39246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39248 if (SWIG_arg_fail(1)) SWIG_fail;
39249 {
39250 PyThreadState* __tstate = wxPyBeginAllowThreads();
39251 result = (int)(arg1)->GetBorder();
39252
39253 wxPyEndAllowThreads(__tstate);
39254 if (PyErr_Occurred()) SWIG_fail;
39255 }
39256 {
39257 resultobj = SWIG_From_int((int)(result));
39258 }
39259 return resultobj;
39260 fail:
39261 return NULL;
39262 }
39263
39264
39265 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39266 PyObject *resultobj;
39267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39268 wxWindow *result;
39269 PyObject * obj0 = 0 ;
39270 char *kwnames[] = {
39271 (char *) "self", NULL
39272 };
39273
39274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39276 if (SWIG_arg_fail(1)) SWIG_fail;
39277 {
39278 PyThreadState* __tstate = wxPyBeginAllowThreads();
39279 result = (wxWindow *)(arg1)->GetWindow();
39280
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 {
39285 resultobj = wxPyMake_wxObject(result, 0);
39286 }
39287 return resultobj;
39288 fail:
39289 return NULL;
39290 }
39291
39292
39293 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39294 PyObject *resultobj;
39295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39296 wxWindow *arg2 = (wxWindow *) 0 ;
39297 PyObject * obj0 = 0 ;
39298 PyObject * obj1 = 0 ;
39299 char *kwnames[] = {
39300 (char *) "self",(char *) "window", NULL
39301 };
39302
39303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39305 if (SWIG_arg_fail(1)) SWIG_fail;
39306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39307 if (SWIG_arg_fail(2)) SWIG_fail;
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 (arg1)->SetWindow(arg2);
39311
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 Py_INCREF(Py_None); resultobj = Py_None;
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39323 PyObject *resultobj;
39324 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39325 wxSizer *result;
39326 PyObject * obj0 = 0 ;
39327 char *kwnames[] = {
39328 (char *) "self", NULL
39329 };
39330
39331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39333 if (SWIG_arg_fail(1)) SWIG_fail;
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 result = (wxSizer *)(arg1)->GetSizer();
39337
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 {
39342 resultobj = wxPyMake_wxObject(result, 0);
39343 }
39344 return resultobj;
39345 fail:
39346 return NULL;
39347 }
39348
39349
39350 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39351 PyObject *resultobj;
39352 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39353 wxSizer *arg2 = (wxSizer *) 0 ;
39354 PyObject * obj0 = 0 ;
39355 PyObject * obj1 = 0 ;
39356 char *kwnames[] = {
39357 (char *) "self",(char *) "sizer", NULL
39358 };
39359
39360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39362 if (SWIG_arg_fail(1)) SWIG_fail;
39363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39364 if (SWIG_arg_fail(2)) SWIG_fail;
39365 {
39366 PyThreadState* __tstate = wxPyBeginAllowThreads();
39367 (arg1)->SetSizer(arg2);
39368
39369 wxPyEndAllowThreads(__tstate);
39370 if (PyErr_Occurred()) SWIG_fail;
39371 }
39372 Py_INCREF(Py_None); resultobj = Py_None;
39373 return resultobj;
39374 fail:
39375 return NULL;
39376 }
39377
39378
39379 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39380 PyObject *resultobj;
39381 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39382 wxSize *result;
39383 PyObject * obj0 = 0 ;
39384 char *kwnames[] = {
39385 (char *) "self", NULL
39386 };
39387
39388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(1)) SWIG_fail;
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 {
39394 wxSize const &_result_ref = (arg1)->GetSpacer();
39395 result = (wxSize *) &_result_ref;
39396 }
39397
39398 wxPyEndAllowThreads(__tstate);
39399 if (PyErr_Occurred()) SWIG_fail;
39400 }
39401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39402 return resultobj;
39403 fail:
39404 return NULL;
39405 }
39406
39407
39408 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39409 PyObject *resultobj;
39410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39411 wxSize *arg2 = 0 ;
39412 wxSize temp2 ;
39413 PyObject * obj0 = 0 ;
39414 PyObject * obj1 = 0 ;
39415 char *kwnames[] = {
39416 (char *) "self",(char *) "size", NULL
39417 };
39418
39419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39421 if (SWIG_arg_fail(1)) SWIG_fail;
39422 {
39423 arg2 = &temp2;
39424 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39425 }
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 (arg1)->SetSpacer((wxSize const &)*arg2);
39429
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 Py_INCREF(Py_None); resultobj = Py_None;
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj;
39442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39443 bool arg2 ;
39444 PyObject * obj0 = 0 ;
39445 PyObject * obj1 = 0 ;
39446 char *kwnames[] = {
39447 (char *) "self",(char *) "show", NULL
39448 };
39449
39450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39452 if (SWIG_arg_fail(1)) SWIG_fail;
39453 {
39454 arg2 = (bool)(SWIG_As_bool(obj1));
39455 if (SWIG_arg_fail(2)) SWIG_fail;
39456 }
39457 {
39458 PyThreadState* __tstate = wxPyBeginAllowThreads();
39459 (arg1)->Show(arg2);
39460
39461 wxPyEndAllowThreads(__tstate);
39462 if (PyErr_Occurred()) SWIG_fail;
39463 }
39464 Py_INCREF(Py_None); resultobj = Py_None;
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj;
39473 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39474 bool result;
39475 PyObject * obj0 = 0 ;
39476 char *kwnames[] = {
39477 (char *) "self", NULL
39478 };
39479
39480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39482 if (SWIG_arg_fail(1)) SWIG_fail;
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (bool)(arg1)->IsShown();
39486
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 {
39491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39492 }
39493 return resultobj;
39494 fail:
39495 return NULL;
39496 }
39497
39498
39499 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39500 PyObject *resultobj;
39501 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39502 wxPoint result;
39503 PyObject * obj0 = 0 ;
39504 char *kwnames[] = {
39505 (char *) "self", NULL
39506 };
39507
39508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39510 if (SWIG_arg_fail(1)) SWIG_fail;
39511 {
39512 PyThreadState* __tstate = wxPyBeginAllowThreads();
39513 result = (arg1)->GetPosition();
39514
39515 wxPyEndAllowThreads(__tstate);
39516 if (PyErr_Occurred()) SWIG_fail;
39517 }
39518 {
39519 wxPoint * resultptr;
39520 resultptr = new wxPoint((wxPoint &)(result));
39521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39522 }
39523 return resultobj;
39524 fail:
39525 return NULL;
39526 }
39527
39528
39529 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39530 PyObject *resultobj;
39531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39532 PyObject *result;
39533 PyObject * obj0 = 0 ;
39534 char *kwnames[] = {
39535 (char *) "self", NULL
39536 };
39537
39538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39540 if (SWIG_arg_fail(1)) SWIG_fail;
39541 {
39542 PyThreadState* __tstate = wxPyBeginAllowThreads();
39543 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39544
39545 wxPyEndAllowThreads(__tstate);
39546 if (PyErr_Occurred()) SWIG_fail;
39547 }
39548 resultobj = result;
39549 return resultobj;
39550 fail:
39551 return NULL;
39552 }
39553
39554
39555 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39556 PyObject *obj;
39557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39558 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39559 Py_INCREF(obj);
39560 return Py_BuildValue((char *)"");
39561 }
39562 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39563 PyObject *resultobj;
39564 wxSizer *arg1 = (wxSizer *) 0 ;
39565 PyObject *arg2 = (PyObject *) 0 ;
39566 PyObject * obj0 = 0 ;
39567 PyObject * obj1 = 0 ;
39568 char *kwnames[] = {
39569 (char *) "self",(char *) "_self", NULL
39570 };
39571
39572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39574 if (SWIG_arg_fail(1)) SWIG_fail;
39575 arg2 = obj1;
39576 {
39577 PyThreadState* __tstate = wxPyBeginAllowThreads();
39578 wxSizer__setOORInfo(arg1,arg2);
39579
39580 wxPyEndAllowThreads(__tstate);
39581 if (PyErr_Occurred()) SWIG_fail;
39582 }
39583 Py_INCREF(Py_None); resultobj = Py_None;
39584 return resultobj;
39585 fail:
39586 return NULL;
39587 }
39588
39589
39590 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39591 PyObject *resultobj;
39592 wxSizer *arg1 = (wxSizer *) 0 ;
39593 PyObject *arg2 = (PyObject *) 0 ;
39594 int arg3 = (int) 0 ;
39595 int arg4 = (int) 0 ;
39596 int arg5 = (int) 0 ;
39597 PyObject *arg6 = (PyObject *) NULL ;
39598 wxSizerItem *result;
39599 PyObject * obj0 = 0 ;
39600 PyObject * obj1 = 0 ;
39601 PyObject * obj2 = 0 ;
39602 PyObject * obj3 = 0 ;
39603 PyObject * obj4 = 0 ;
39604 PyObject * obj5 = 0 ;
39605 char *kwnames[] = {
39606 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39607 };
39608
39609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39611 if (SWIG_arg_fail(1)) SWIG_fail;
39612 arg2 = obj1;
39613 if (obj2) {
39614 {
39615 arg3 = (int)(SWIG_As_int(obj2));
39616 if (SWIG_arg_fail(3)) SWIG_fail;
39617 }
39618 }
39619 if (obj3) {
39620 {
39621 arg4 = (int)(SWIG_As_int(obj3));
39622 if (SWIG_arg_fail(4)) SWIG_fail;
39623 }
39624 }
39625 if (obj4) {
39626 {
39627 arg5 = (int)(SWIG_As_int(obj4));
39628 if (SWIG_arg_fail(5)) SWIG_fail;
39629 }
39630 }
39631 if (obj5) {
39632 arg6 = obj5;
39633 }
39634 {
39635 PyThreadState* __tstate = wxPyBeginAllowThreads();
39636 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39637
39638 wxPyEndAllowThreads(__tstate);
39639 if (PyErr_Occurred()) SWIG_fail;
39640 }
39641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39642 return resultobj;
39643 fail:
39644 return NULL;
39645 }
39646
39647
39648 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39649 PyObject *resultobj;
39650 wxSizer *arg1 = (wxSizer *) 0 ;
39651 int arg2 ;
39652 PyObject *arg3 = (PyObject *) 0 ;
39653 int arg4 = (int) 0 ;
39654 int arg5 = (int) 0 ;
39655 int arg6 = (int) 0 ;
39656 PyObject *arg7 = (PyObject *) NULL ;
39657 wxSizerItem *result;
39658 PyObject * obj0 = 0 ;
39659 PyObject * obj1 = 0 ;
39660 PyObject * obj2 = 0 ;
39661 PyObject * obj3 = 0 ;
39662 PyObject * obj4 = 0 ;
39663 PyObject * obj5 = 0 ;
39664 PyObject * obj6 = 0 ;
39665 char *kwnames[] = {
39666 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39667 };
39668
39669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39671 if (SWIG_arg_fail(1)) SWIG_fail;
39672 {
39673 arg2 = (int)(SWIG_As_int(obj1));
39674 if (SWIG_arg_fail(2)) SWIG_fail;
39675 }
39676 arg3 = obj2;
39677 if (obj3) {
39678 {
39679 arg4 = (int)(SWIG_As_int(obj3));
39680 if (SWIG_arg_fail(4)) SWIG_fail;
39681 }
39682 }
39683 if (obj4) {
39684 {
39685 arg5 = (int)(SWIG_As_int(obj4));
39686 if (SWIG_arg_fail(5)) SWIG_fail;
39687 }
39688 }
39689 if (obj5) {
39690 {
39691 arg6 = (int)(SWIG_As_int(obj5));
39692 if (SWIG_arg_fail(6)) SWIG_fail;
39693 }
39694 }
39695 if (obj6) {
39696 arg7 = obj6;
39697 }
39698 {
39699 PyThreadState* __tstate = wxPyBeginAllowThreads();
39700 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39701
39702 wxPyEndAllowThreads(__tstate);
39703 if (PyErr_Occurred()) SWIG_fail;
39704 }
39705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39706 return resultobj;
39707 fail:
39708 return NULL;
39709 }
39710
39711
39712 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39713 PyObject *resultobj;
39714 wxSizer *arg1 = (wxSizer *) 0 ;
39715 PyObject *arg2 = (PyObject *) 0 ;
39716 int arg3 = (int) 0 ;
39717 int arg4 = (int) 0 ;
39718 int arg5 = (int) 0 ;
39719 PyObject *arg6 = (PyObject *) NULL ;
39720 wxSizerItem *result;
39721 PyObject * obj0 = 0 ;
39722 PyObject * obj1 = 0 ;
39723 PyObject * obj2 = 0 ;
39724 PyObject * obj3 = 0 ;
39725 PyObject * obj4 = 0 ;
39726 PyObject * obj5 = 0 ;
39727 char *kwnames[] = {
39728 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39729 };
39730
39731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39733 if (SWIG_arg_fail(1)) SWIG_fail;
39734 arg2 = obj1;
39735 if (obj2) {
39736 {
39737 arg3 = (int)(SWIG_As_int(obj2));
39738 if (SWIG_arg_fail(3)) SWIG_fail;
39739 }
39740 }
39741 if (obj3) {
39742 {
39743 arg4 = (int)(SWIG_As_int(obj3));
39744 if (SWIG_arg_fail(4)) SWIG_fail;
39745 }
39746 }
39747 if (obj4) {
39748 {
39749 arg5 = (int)(SWIG_As_int(obj4));
39750 if (SWIG_arg_fail(5)) SWIG_fail;
39751 }
39752 }
39753 if (obj5) {
39754 arg6 = obj5;
39755 }
39756 {
39757 PyThreadState* __tstate = wxPyBeginAllowThreads();
39758 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39759
39760 wxPyEndAllowThreads(__tstate);
39761 if (PyErr_Occurred()) SWIG_fail;
39762 }
39763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39764 return resultobj;
39765 fail:
39766 return NULL;
39767 }
39768
39769
39770 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39771 PyObject *resultobj;
39772 wxSizer *arg1 = (wxSizer *) 0 ;
39773 PyObject *arg2 = (PyObject *) 0 ;
39774 bool result;
39775 PyObject * obj0 = 0 ;
39776 PyObject * obj1 = 0 ;
39777 char *kwnames[] = {
39778 (char *) "self",(char *) "item", NULL
39779 };
39780
39781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39783 if (SWIG_arg_fail(1)) SWIG_fail;
39784 arg2 = obj1;
39785 {
39786 PyThreadState* __tstate = wxPyBeginAllowThreads();
39787 result = (bool)wxSizer_Remove(arg1,arg2);
39788
39789 wxPyEndAllowThreads(__tstate);
39790 if (PyErr_Occurred()) SWIG_fail;
39791 }
39792 {
39793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39794 }
39795 return resultobj;
39796 fail:
39797 return NULL;
39798 }
39799
39800
39801 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39802 PyObject *resultobj;
39803 wxSizer *arg1 = (wxSizer *) 0 ;
39804 PyObject *arg2 = (PyObject *) 0 ;
39805 bool result;
39806 PyObject * obj0 = 0 ;
39807 PyObject * obj1 = 0 ;
39808 char *kwnames[] = {
39809 (char *) "self",(char *) "item", NULL
39810 };
39811
39812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39814 if (SWIG_arg_fail(1)) SWIG_fail;
39815 arg2 = obj1;
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 result = (bool)wxSizer_Detach(arg1,arg2);
39819
39820 wxPyEndAllowThreads(__tstate);
39821 if (PyErr_Occurred()) SWIG_fail;
39822 }
39823 {
39824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39825 }
39826 return resultobj;
39827 fail:
39828 return NULL;
39829 }
39830
39831
39832 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39833 PyObject *resultobj;
39834 wxSizer *arg1 = (wxSizer *) 0 ;
39835 PyObject *arg2 = (PyObject *) 0 ;
39836 wxSizerItem *result;
39837 PyObject * obj0 = 0 ;
39838 PyObject * obj1 = 0 ;
39839 char *kwnames[] = {
39840 (char *) "self",(char *) "item", NULL
39841 };
39842
39843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39845 if (SWIG_arg_fail(1)) SWIG_fail;
39846 arg2 = obj1;
39847 {
39848 PyThreadState* __tstate = wxPyBeginAllowThreads();
39849 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39850
39851 wxPyEndAllowThreads(__tstate);
39852 if (PyErr_Occurred()) SWIG_fail;
39853 }
39854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39855 return resultobj;
39856 fail:
39857 return NULL;
39858 }
39859
39860
39861 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39862 PyObject *resultobj;
39863 wxSizer *arg1 = (wxSizer *) 0 ;
39864 PyObject *arg2 = (PyObject *) 0 ;
39865 wxSize *arg3 = 0 ;
39866 wxSize temp3 ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 PyObject * obj2 = 0 ;
39870 char *kwnames[] = {
39871 (char *) "self",(char *) "item",(char *) "size", NULL
39872 };
39873
39874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39876 if (SWIG_arg_fail(1)) SWIG_fail;
39877 arg2 = obj1;
39878 {
39879 arg3 = &temp3;
39880 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39881 }
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39885
39886 wxPyEndAllowThreads(__tstate);
39887 if (PyErr_Occurred()) SWIG_fail;
39888 }
39889 Py_INCREF(Py_None); resultobj = Py_None;
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39897 PyObject *resultobj;
39898 wxSizer *arg1 = (wxSizer *) 0 ;
39899 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39900 wxSizerItem *result;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 char *kwnames[] = {
39904 (char *) "self",(char *) "item", NULL
39905 };
39906
39907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39909 if (SWIG_arg_fail(1)) SWIG_fail;
39910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39911 if (SWIG_arg_fail(2)) SWIG_fail;
39912 {
39913 PyThreadState* __tstate = wxPyBeginAllowThreads();
39914 result = (wxSizerItem *)(arg1)->Add(arg2);
39915
39916 wxPyEndAllowThreads(__tstate);
39917 if (PyErr_Occurred()) SWIG_fail;
39918 }
39919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39920 return resultobj;
39921 fail:
39922 return NULL;
39923 }
39924
39925
39926 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39927 PyObject *resultobj;
39928 wxSizer *arg1 = (wxSizer *) 0 ;
39929 size_t arg2 ;
39930 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39931 wxSizerItem *result;
39932 PyObject * obj0 = 0 ;
39933 PyObject * obj1 = 0 ;
39934 PyObject * obj2 = 0 ;
39935 char *kwnames[] = {
39936 (char *) "self",(char *) "index",(char *) "item", NULL
39937 };
39938
39939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) 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 {
39943 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39944 if (SWIG_arg_fail(2)) SWIG_fail;
39945 }
39946 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39947 if (SWIG_arg_fail(3)) SWIG_fail;
39948 {
39949 PyThreadState* __tstate = wxPyBeginAllowThreads();
39950 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39951
39952 wxPyEndAllowThreads(__tstate);
39953 if (PyErr_Occurred()) SWIG_fail;
39954 }
39955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39956 return resultobj;
39957 fail:
39958 return NULL;
39959 }
39960
39961
39962 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39963 PyObject *resultobj;
39964 wxSizer *arg1 = (wxSizer *) 0 ;
39965 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39966 wxSizerItem *result;
39967 PyObject * obj0 = 0 ;
39968 PyObject * obj1 = 0 ;
39969 char *kwnames[] = {
39970 (char *) "self",(char *) "item", NULL
39971 };
39972
39973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39975 if (SWIG_arg_fail(1)) SWIG_fail;
39976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39977 if (SWIG_arg_fail(2)) SWIG_fail;
39978 {
39979 PyThreadState* __tstate = wxPyBeginAllowThreads();
39980 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39981
39982 wxPyEndAllowThreads(__tstate);
39983 if (PyErr_Occurred()) SWIG_fail;
39984 }
39985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39986 return resultobj;
39987 fail:
39988 return NULL;
39989 }
39990
39991
39992 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39993 PyObject *resultobj;
39994 wxSizer *arg1 = (wxSizer *) 0 ;
39995 int arg2 ;
39996 int arg3 ;
39997 int arg4 ;
39998 int arg5 ;
39999 PyObject * obj0 = 0 ;
40000 PyObject * obj1 = 0 ;
40001 PyObject * obj2 = 0 ;
40002 PyObject * obj3 = 0 ;
40003 PyObject * obj4 = 0 ;
40004 char *kwnames[] = {
40005 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40006 };
40007
40008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40010 if (SWIG_arg_fail(1)) SWIG_fail;
40011 {
40012 arg2 = (int)(SWIG_As_int(obj1));
40013 if (SWIG_arg_fail(2)) SWIG_fail;
40014 }
40015 {
40016 arg3 = (int)(SWIG_As_int(obj2));
40017 if (SWIG_arg_fail(3)) SWIG_fail;
40018 }
40019 {
40020 arg4 = (int)(SWIG_As_int(obj3));
40021 if (SWIG_arg_fail(4)) SWIG_fail;
40022 }
40023 {
40024 arg5 = (int)(SWIG_As_int(obj4));
40025 if (SWIG_arg_fail(5)) SWIG_fail;
40026 }
40027 {
40028 PyThreadState* __tstate = wxPyBeginAllowThreads();
40029 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40030
40031 wxPyEndAllowThreads(__tstate);
40032 if (PyErr_Occurred()) SWIG_fail;
40033 }
40034 Py_INCREF(Py_None); resultobj = Py_None;
40035 return resultobj;
40036 fail:
40037 return NULL;
40038 }
40039
40040
40041 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40042 PyObject *resultobj;
40043 wxSizer *arg1 = (wxSizer *) 0 ;
40044 wxSize *arg2 = 0 ;
40045 wxSize temp2 ;
40046 PyObject * obj0 = 0 ;
40047 PyObject * obj1 = 0 ;
40048 char *kwnames[] = {
40049 (char *) "self",(char *) "size", NULL
40050 };
40051
40052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40054 if (SWIG_arg_fail(1)) SWIG_fail;
40055 {
40056 arg2 = &temp2;
40057 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40058 }
40059 {
40060 PyThreadState* __tstate = wxPyBeginAllowThreads();
40061 (arg1)->SetMinSize((wxSize const &)*arg2);
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_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40074 PyObject *resultobj;
40075 wxSizer *arg1 = (wxSizer *) 0 ;
40076 wxSize result;
40077 PyObject * obj0 = 0 ;
40078 char *kwnames[] = {
40079 (char *) "self", NULL
40080 };
40081
40082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40084 if (SWIG_arg_fail(1)) SWIG_fail;
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 result = (arg1)->GetSize();
40088
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 {
40093 wxSize * resultptr;
40094 resultptr = new wxSize((wxSize &)(result));
40095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40096 }
40097 return resultobj;
40098 fail:
40099 return NULL;
40100 }
40101
40102
40103 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40104 PyObject *resultobj;
40105 wxSizer *arg1 = (wxSizer *) 0 ;
40106 wxPoint result;
40107 PyObject * obj0 = 0 ;
40108 char *kwnames[] = {
40109 (char *) "self", NULL
40110 };
40111
40112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40114 if (SWIG_arg_fail(1)) SWIG_fail;
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 result = (arg1)->GetPosition();
40118
40119 wxPyEndAllowThreads(__tstate);
40120 if (PyErr_Occurred()) SWIG_fail;
40121 }
40122 {
40123 wxPoint * resultptr;
40124 resultptr = new wxPoint((wxPoint &)(result));
40125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40126 }
40127 return resultobj;
40128 fail:
40129 return NULL;
40130 }
40131
40132
40133 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40134 PyObject *resultobj;
40135 wxSizer *arg1 = (wxSizer *) 0 ;
40136 wxSize result;
40137 PyObject * obj0 = 0 ;
40138 char *kwnames[] = {
40139 (char *) "self", NULL
40140 };
40141
40142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40144 if (SWIG_arg_fail(1)) SWIG_fail;
40145 {
40146 PyThreadState* __tstate = wxPyBeginAllowThreads();
40147 result = (arg1)->GetMinSize();
40148
40149 wxPyEndAllowThreads(__tstate);
40150 if (PyErr_Occurred()) SWIG_fail;
40151 }
40152 {
40153 wxSize * resultptr;
40154 resultptr = new wxSize((wxSize &)(result));
40155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40156 }
40157 return resultobj;
40158 fail:
40159 return NULL;
40160 }
40161
40162
40163 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40164 PyObject *resultobj;
40165 wxSizer *arg1 = (wxSizer *) 0 ;
40166 PyObject * obj0 = 0 ;
40167 char *kwnames[] = {
40168 (char *) "self", NULL
40169 };
40170
40171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40173 if (SWIG_arg_fail(1)) SWIG_fail;
40174 {
40175 PyThreadState* __tstate = wxPyBeginAllowThreads();
40176 (arg1)->RecalcSizes();
40177
40178 wxPyEndAllowThreads(__tstate);
40179 if (PyErr_Occurred()) SWIG_fail;
40180 }
40181 Py_INCREF(Py_None); resultobj = Py_None;
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj;
40190 wxSizer *arg1 = (wxSizer *) 0 ;
40191 wxSize result;
40192 PyObject * obj0 = 0 ;
40193 char *kwnames[] = {
40194 (char *) "self", NULL
40195 };
40196
40197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40199 if (SWIG_arg_fail(1)) SWIG_fail;
40200 {
40201 PyThreadState* __tstate = wxPyBeginAllowThreads();
40202 result = (arg1)->CalcMin();
40203
40204 wxPyEndAllowThreads(__tstate);
40205 if (PyErr_Occurred()) SWIG_fail;
40206 }
40207 {
40208 wxSize * resultptr;
40209 resultptr = new wxSize((wxSize &)(result));
40210 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40211 }
40212 return resultobj;
40213 fail:
40214 return NULL;
40215 }
40216
40217
40218 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40219 PyObject *resultobj;
40220 wxSizer *arg1 = (wxSizer *) 0 ;
40221 PyObject * obj0 = 0 ;
40222 char *kwnames[] = {
40223 (char *) "self", NULL
40224 };
40225
40226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40228 if (SWIG_arg_fail(1)) SWIG_fail;
40229 {
40230 PyThreadState* __tstate = wxPyBeginAllowThreads();
40231 (arg1)->Layout();
40232
40233 wxPyEndAllowThreads(__tstate);
40234 if (PyErr_Occurred()) SWIG_fail;
40235 }
40236 Py_INCREF(Py_None); resultobj = Py_None;
40237 return resultobj;
40238 fail:
40239 return NULL;
40240 }
40241
40242
40243 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40244 PyObject *resultobj;
40245 wxSizer *arg1 = (wxSizer *) 0 ;
40246 wxWindow *arg2 = (wxWindow *) 0 ;
40247 wxSize result;
40248 PyObject * obj0 = 0 ;
40249 PyObject * obj1 = 0 ;
40250 char *kwnames[] = {
40251 (char *) "self",(char *) "window", NULL
40252 };
40253
40254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40256 if (SWIG_arg_fail(1)) SWIG_fail;
40257 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40258 if (SWIG_arg_fail(2)) SWIG_fail;
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 result = (arg1)->Fit(arg2);
40262
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 {
40267 wxSize * resultptr;
40268 resultptr = new wxSize((wxSize &)(result));
40269 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40270 }
40271 return resultobj;
40272 fail:
40273 return NULL;
40274 }
40275
40276
40277 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40278 PyObject *resultobj;
40279 wxSizer *arg1 = (wxSizer *) 0 ;
40280 wxWindow *arg2 = (wxWindow *) 0 ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 char *kwnames[] = {
40284 (char *) "self",(char *) "window", NULL
40285 };
40286
40287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40289 if (SWIG_arg_fail(1)) SWIG_fail;
40290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40291 if (SWIG_arg_fail(2)) SWIG_fail;
40292 {
40293 PyThreadState* __tstate = wxPyBeginAllowThreads();
40294 (arg1)->FitInside(arg2);
40295
40296 wxPyEndAllowThreads(__tstate);
40297 if (PyErr_Occurred()) SWIG_fail;
40298 }
40299 Py_INCREF(Py_None); resultobj = Py_None;
40300 return resultobj;
40301 fail:
40302 return NULL;
40303 }
40304
40305
40306 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40307 PyObject *resultobj;
40308 wxSizer *arg1 = (wxSizer *) 0 ;
40309 wxWindow *arg2 = (wxWindow *) 0 ;
40310 PyObject * obj0 = 0 ;
40311 PyObject * obj1 = 0 ;
40312 char *kwnames[] = {
40313 (char *) "self",(char *) "window", NULL
40314 };
40315
40316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40318 if (SWIG_arg_fail(1)) SWIG_fail;
40319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40320 if (SWIG_arg_fail(2)) SWIG_fail;
40321 {
40322 PyThreadState* __tstate = wxPyBeginAllowThreads();
40323 (arg1)->SetSizeHints(arg2);
40324
40325 wxPyEndAllowThreads(__tstate);
40326 if (PyErr_Occurred()) SWIG_fail;
40327 }
40328 Py_INCREF(Py_None); resultobj = Py_None;
40329 return resultobj;
40330 fail:
40331 return NULL;
40332 }
40333
40334
40335 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40336 PyObject *resultobj;
40337 wxSizer *arg1 = (wxSizer *) 0 ;
40338 wxWindow *arg2 = (wxWindow *) 0 ;
40339 PyObject * obj0 = 0 ;
40340 PyObject * obj1 = 0 ;
40341 char *kwnames[] = {
40342 (char *) "self",(char *) "window", NULL
40343 };
40344
40345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40347 if (SWIG_arg_fail(1)) SWIG_fail;
40348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40349 if (SWIG_arg_fail(2)) SWIG_fail;
40350 {
40351 PyThreadState* __tstate = wxPyBeginAllowThreads();
40352 (arg1)->SetVirtualSizeHints(arg2);
40353
40354 wxPyEndAllowThreads(__tstate);
40355 if (PyErr_Occurred()) SWIG_fail;
40356 }
40357 Py_INCREF(Py_None); resultobj = Py_None;
40358 return resultobj;
40359 fail:
40360 return NULL;
40361 }
40362
40363
40364 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40365 PyObject *resultobj;
40366 wxSizer *arg1 = (wxSizer *) 0 ;
40367 bool arg2 = (bool) false ;
40368 PyObject * obj0 = 0 ;
40369 PyObject * obj1 = 0 ;
40370 char *kwnames[] = {
40371 (char *) "self",(char *) "deleteWindows", NULL
40372 };
40373
40374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40376 if (SWIG_arg_fail(1)) SWIG_fail;
40377 if (obj1) {
40378 {
40379 arg2 = (bool)(SWIG_As_bool(obj1));
40380 if (SWIG_arg_fail(2)) SWIG_fail;
40381 }
40382 }
40383 {
40384 PyThreadState* __tstate = wxPyBeginAllowThreads();
40385 (arg1)->Clear(arg2);
40386
40387 wxPyEndAllowThreads(__tstate);
40388 if (PyErr_Occurred()) SWIG_fail;
40389 }
40390 Py_INCREF(Py_None); resultobj = Py_None;
40391 return resultobj;
40392 fail:
40393 return NULL;
40394 }
40395
40396
40397 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40398 PyObject *resultobj;
40399 wxSizer *arg1 = (wxSizer *) 0 ;
40400 PyObject * obj0 = 0 ;
40401 char *kwnames[] = {
40402 (char *) "self", NULL
40403 };
40404
40405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40407 if (SWIG_arg_fail(1)) SWIG_fail;
40408 {
40409 PyThreadState* __tstate = wxPyBeginAllowThreads();
40410 (arg1)->DeleteWindows();
40411
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 Py_INCREF(Py_None); resultobj = Py_None;
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40423 PyObject *resultobj;
40424 wxSizer *arg1 = (wxSizer *) 0 ;
40425 PyObject *result;
40426 PyObject * obj0 = 0 ;
40427 char *kwnames[] = {
40428 (char *) "self", NULL
40429 };
40430
40431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40433 if (SWIG_arg_fail(1)) SWIG_fail;
40434 {
40435 PyThreadState* __tstate = wxPyBeginAllowThreads();
40436 result = (PyObject *)wxSizer_GetChildren(arg1);
40437
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 resultobj = result;
40442 return resultobj;
40443 fail:
40444 return NULL;
40445 }
40446
40447
40448 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40449 PyObject *resultobj;
40450 wxSizer *arg1 = (wxSizer *) 0 ;
40451 PyObject *arg2 = (PyObject *) 0 ;
40452 bool arg3 = (bool) true ;
40453 bool arg4 = (bool) false ;
40454 bool result;
40455 PyObject * obj0 = 0 ;
40456 PyObject * obj1 = 0 ;
40457 PyObject * obj2 = 0 ;
40458 PyObject * obj3 = 0 ;
40459 char *kwnames[] = {
40460 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40461 };
40462
40463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = obj1;
40467 if (obj2) {
40468 {
40469 arg3 = (bool)(SWIG_As_bool(obj2));
40470 if (SWIG_arg_fail(3)) SWIG_fail;
40471 }
40472 }
40473 if (obj3) {
40474 {
40475 arg4 = (bool)(SWIG_As_bool(obj3));
40476 if (SWIG_arg_fail(4)) SWIG_fail;
40477 }
40478 }
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40482
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40488 }
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40496 PyObject *resultobj;
40497 wxSizer *arg1 = (wxSizer *) 0 ;
40498 PyObject *arg2 = (PyObject *) 0 ;
40499 bool result;
40500 PyObject * obj0 = 0 ;
40501 PyObject * obj1 = 0 ;
40502 char *kwnames[] = {
40503 (char *) "self",(char *) "item", NULL
40504 };
40505
40506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40508 if (SWIG_arg_fail(1)) SWIG_fail;
40509 arg2 = obj1;
40510 {
40511 PyThreadState* __tstate = wxPyBeginAllowThreads();
40512 result = (bool)wxSizer_IsShown(arg1,arg2);
40513
40514 wxPyEndAllowThreads(__tstate);
40515 if (PyErr_Occurred()) SWIG_fail;
40516 }
40517 {
40518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40519 }
40520 return resultobj;
40521 fail:
40522 return NULL;
40523 }
40524
40525
40526 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40527 PyObject *resultobj;
40528 wxSizer *arg1 = (wxSizer *) 0 ;
40529 bool arg2 ;
40530 PyObject * obj0 = 0 ;
40531 PyObject * obj1 = 0 ;
40532 char *kwnames[] = {
40533 (char *) "self",(char *) "show", NULL
40534 };
40535
40536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40538 if (SWIG_arg_fail(1)) SWIG_fail;
40539 {
40540 arg2 = (bool)(SWIG_As_bool(obj1));
40541 if (SWIG_arg_fail(2)) SWIG_fail;
40542 }
40543 {
40544 PyThreadState* __tstate = wxPyBeginAllowThreads();
40545 (arg1)->ShowItems(arg2);
40546
40547 wxPyEndAllowThreads(__tstate);
40548 if (PyErr_Occurred()) SWIG_fail;
40549 }
40550 Py_INCREF(Py_None); resultobj = Py_None;
40551 return resultobj;
40552 fail:
40553 return NULL;
40554 }
40555
40556
40557 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40558 PyObject *obj;
40559 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40560 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40561 Py_INCREF(obj);
40562 return Py_BuildValue((char *)"");
40563 }
40564 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40565 PyObject *resultobj;
40566 wxPySizer *result;
40567 char *kwnames[] = {
40568 NULL
40569 };
40570
40571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40572 {
40573 PyThreadState* __tstate = wxPyBeginAllowThreads();
40574 result = (wxPySizer *)new wxPySizer();
40575
40576 wxPyEndAllowThreads(__tstate);
40577 if (PyErr_Occurred()) SWIG_fail;
40578 }
40579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40580 return resultobj;
40581 fail:
40582 return NULL;
40583 }
40584
40585
40586 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40587 PyObject *resultobj;
40588 wxPySizer *arg1 = (wxPySizer *) 0 ;
40589 PyObject *arg2 = (PyObject *) 0 ;
40590 PyObject *arg3 = (PyObject *) 0 ;
40591 PyObject * obj0 = 0 ;
40592 PyObject * obj1 = 0 ;
40593 PyObject * obj2 = 0 ;
40594 char *kwnames[] = {
40595 (char *) "self",(char *) "self",(char *) "_class", NULL
40596 };
40597
40598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40600 if (SWIG_arg_fail(1)) SWIG_fail;
40601 arg2 = obj1;
40602 arg3 = obj2;
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 (arg1)->_setCallbackInfo(arg2,arg3);
40606
40607 wxPyEndAllowThreads(__tstate);
40608 if (PyErr_Occurred()) SWIG_fail;
40609 }
40610 Py_INCREF(Py_None); resultobj = Py_None;
40611 return resultobj;
40612 fail:
40613 return NULL;
40614 }
40615
40616
40617 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40618 PyObject *obj;
40619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40620 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40621 Py_INCREF(obj);
40622 return Py_BuildValue((char *)"");
40623 }
40624 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40625 PyObject *resultobj;
40626 int arg1 = (int) wxHORIZONTAL ;
40627 wxBoxSizer *result;
40628 PyObject * obj0 = 0 ;
40629 char *kwnames[] = {
40630 (char *) "orient", NULL
40631 };
40632
40633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40634 if (obj0) {
40635 {
40636 arg1 = (int)(SWIG_As_int(obj0));
40637 if (SWIG_arg_fail(1)) SWIG_fail;
40638 }
40639 }
40640 {
40641 PyThreadState* __tstate = wxPyBeginAllowThreads();
40642 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40643
40644 wxPyEndAllowThreads(__tstate);
40645 if (PyErr_Occurred()) SWIG_fail;
40646 }
40647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40648 return resultobj;
40649 fail:
40650 return NULL;
40651 }
40652
40653
40654 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40655 PyObject *resultobj;
40656 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40657 int result;
40658 PyObject * obj0 = 0 ;
40659 char *kwnames[] = {
40660 (char *) "self", NULL
40661 };
40662
40663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40665 if (SWIG_arg_fail(1)) SWIG_fail;
40666 {
40667 PyThreadState* __tstate = wxPyBeginAllowThreads();
40668 result = (int)(arg1)->GetOrientation();
40669
40670 wxPyEndAllowThreads(__tstate);
40671 if (PyErr_Occurred()) SWIG_fail;
40672 }
40673 {
40674 resultobj = SWIG_From_int((int)(result));
40675 }
40676 return resultobj;
40677 fail:
40678 return NULL;
40679 }
40680
40681
40682 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40683 PyObject *resultobj;
40684 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40685 int arg2 ;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 char *kwnames[] = {
40689 (char *) "self",(char *) "orient", NULL
40690 };
40691
40692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40694 if (SWIG_arg_fail(1)) SWIG_fail;
40695 {
40696 arg2 = (int)(SWIG_As_int(obj1));
40697 if (SWIG_arg_fail(2)) SWIG_fail;
40698 }
40699 {
40700 PyThreadState* __tstate = wxPyBeginAllowThreads();
40701 (arg1)->SetOrientation(arg2);
40702
40703 wxPyEndAllowThreads(__tstate);
40704 if (PyErr_Occurred()) SWIG_fail;
40705 }
40706 Py_INCREF(Py_None); resultobj = Py_None;
40707 return resultobj;
40708 fail:
40709 return NULL;
40710 }
40711
40712
40713 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40714 PyObject *obj;
40715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40716 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40717 Py_INCREF(obj);
40718 return Py_BuildValue((char *)"");
40719 }
40720 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40721 PyObject *resultobj;
40722 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40723 int arg2 = (int) wxHORIZONTAL ;
40724 wxStaticBoxSizer *result;
40725 PyObject * obj0 = 0 ;
40726 PyObject * obj1 = 0 ;
40727 char *kwnames[] = {
40728 (char *) "box",(char *) "orient", NULL
40729 };
40730
40731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40733 if (SWIG_arg_fail(1)) SWIG_fail;
40734 if (obj1) {
40735 {
40736 arg2 = (int)(SWIG_As_int(obj1));
40737 if (SWIG_arg_fail(2)) SWIG_fail;
40738 }
40739 }
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40743
40744 wxPyEndAllowThreads(__tstate);
40745 if (PyErr_Occurred()) SWIG_fail;
40746 }
40747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40748 return resultobj;
40749 fail:
40750 return NULL;
40751 }
40752
40753
40754 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40755 PyObject *resultobj;
40756 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40757 wxStaticBox *result;
40758 PyObject * obj0 = 0 ;
40759 char *kwnames[] = {
40760 (char *) "self", NULL
40761 };
40762
40763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40765 if (SWIG_arg_fail(1)) SWIG_fail;
40766 {
40767 PyThreadState* __tstate = wxPyBeginAllowThreads();
40768 result = (wxStaticBox *)(arg1)->GetStaticBox();
40769
40770 wxPyEndAllowThreads(__tstate);
40771 if (PyErr_Occurred()) SWIG_fail;
40772 }
40773 {
40774 resultobj = wxPyMake_wxObject(result, 0);
40775 }
40776 return resultobj;
40777 fail:
40778 return NULL;
40779 }
40780
40781
40782 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40783 PyObject *obj;
40784 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40785 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40786 Py_INCREF(obj);
40787 return Py_BuildValue((char *)"");
40788 }
40789 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40790 PyObject *resultobj;
40791 int arg1 = (int) 1 ;
40792 int arg2 = (int) 0 ;
40793 int arg3 = (int) 0 ;
40794 int arg4 = (int) 0 ;
40795 wxGridSizer *result;
40796 PyObject * obj0 = 0 ;
40797 PyObject * obj1 = 0 ;
40798 PyObject * obj2 = 0 ;
40799 PyObject * obj3 = 0 ;
40800 char *kwnames[] = {
40801 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40802 };
40803
40804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40805 if (obj0) {
40806 {
40807 arg1 = (int)(SWIG_As_int(obj0));
40808 if (SWIG_arg_fail(1)) SWIG_fail;
40809 }
40810 }
40811 if (obj1) {
40812 {
40813 arg2 = (int)(SWIG_As_int(obj1));
40814 if (SWIG_arg_fail(2)) SWIG_fail;
40815 }
40816 }
40817 if (obj2) {
40818 {
40819 arg3 = (int)(SWIG_As_int(obj2));
40820 if (SWIG_arg_fail(3)) SWIG_fail;
40821 }
40822 }
40823 if (obj3) {
40824 {
40825 arg4 = (int)(SWIG_As_int(obj3));
40826 if (SWIG_arg_fail(4)) SWIG_fail;
40827 }
40828 }
40829 {
40830 PyThreadState* __tstate = wxPyBeginAllowThreads();
40831 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40832
40833 wxPyEndAllowThreads(__tstate);
40834 if (PyErr_Occurred()) SWIG_fail;
40835 }
40836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40844 PyObject *resultobj;
40845 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40846 int arg2 ;
40847 PyObject * obj0 = 0 ;
40848 PyObject * obj1 = 0 ;
40849 char *kwnames[] = {
40850 (char *) "self",(char *) "cols", NULL
40851 };
40852
40853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40855 if (SWIG_arg_fail(1)) SWIG_fail;
40856 {
40857 arg2 = (int)(SWIG_As_int(obj1));
40858 if (SWIG_arg_fail(2)) SWIG_fail;
40859 }
40860 {
40861 PyThreadState* __tstate = wxPyBeginAllowThreads();
40862 (arg1)->SetCols(arg2);
40863
40864 wxPyEndAllowThreads(__tstate);
40865 if (PyErr_Occurred()) SWIG_fail;
40866 }
40867 Py_INCREF(Py_None); resultobj = Py_None;
40868 return resultobj;
40869 fail:
40870 return NULL;
40871 }
40872
40873
40874 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40875 PyObject *resultobj;
40876 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40877 int arg2 ;
40878 PyObject * obj0 = 0 ;
40879 PyObject * obj1 = 0 ;
40880 char *kwnames[] = {
40881 (char *) "self",(char *) "rows", NULL
40882 };
40883
40884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40886 if (SWIG_arg_fail(1)) SWIG_fail;
40887 {
40888 arg2 = (int)(SWIG_As_int(obj1));
40889 if (SWIG_arg_fail(2)) SWIG_fail;
40890 }
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 (arg1)->SetRows(arg2);
40894
40895 wxPyEndAllowThreads(__tstate);
40896 if (PyErr_Occurred()) SWIG_fail;
40897 }
40898 Py_INCREF(Py_None); resultobj = Py_None;
40899 return resultobj;
40900 fail:
40901 return NULL;
40902 }
40903
40904
40905 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40906 PyObject *resultobj;
40907 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40908 int arg2 ;
40909 PyObject * obj0 = 0 ;
40910 PyObject * obj1 = 0 ;
40911 char *kwnames[] = {
40912 (char *) "self",(char *) "gap", NULL
40913 };
40914
40915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40917 if (SWIG_arg_fail(1)) SWIG_fail;
40918 {
40919 arg2 = (int)(SWIG_As_int(obj1));
40920 if (SWIG_arg_fail(2)) SWIG_fail;
40921 }
40922 {
40923 PyThreadState* __tstate = wxPyBeginAllowThreads();
40924 (arg1)->SetVGap(arg2);
40925
40926 wxPyEndAllowThreads(__tstate);
40927 if (PyErr_Occurred()) SWIG_fail;
40928 }
40929 Py_INCREF(Py_None); resultobj = Py_None;
40930 return resultobj;
40931 fail:
40932 return NULL;
40933 }
40934
40935
40936 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40937 PyObject *resultobj;
40938 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40939 int arg2 ;
40940 PyObject * obj0 = 0 ;
40941 PyObject * obj1 = 0 ;
40942 char *kwnames[] = {
40943 (char *) "self",(char *) "gap", NULL
40944 };
40945
40946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40948 if (SWIG_arg_fail(1)) SWIG_fail;
40949 {
40950 arg2 = (int)(SWIG_As_int(obj1));
40951 if (SWIG_arg_fail(2)) SWIG_fail;
40952 }
40953 {
40954 PyThreadState* __tstate = wxPyBeginAllowThreads();
40955 (arg1)->SetHGap(arg2);
40956
40957 wxPyEndAllowThreads(__tstate);
40958 if (PyErr_Occurred()) SWIG_fail;
40959 }
40960 Py_INCREF(Py_None); resultobj = Py_None;
40961 return resultobj;
40962 fail:
40963 return NULL;
40964 }
40965
40966
40967 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40968 PyObject *resultobj;
40969 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40970 int result;
40971 PyObject * obj0 = 0 ;
40972 char *kwnames[] = {
40973 (char *) "self", NULL
40974 };
40975
40976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40978 if (SWIG_arg_fail(1)) SWIG_fail;
40979 {
40980 PyThreadState* __tstate = wxPyBeginAllowThreads();
40981 result = (int)(arg1)->GetCols();
40982
40983 wxPyEndAllowThreads(__tstate);
40984 if (PyErr_Occurred()) SWIG_fail;
40985 }
40986 {
40987 resultobj = SWIG_From_int((int)(result));
40988 }
40989 return resultobj;
40990 fail:
40991 return NULL;
40992 }
40993
40994
40995 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40996 PyObject *resultobj;
40997 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40998 int result;
40999 PyObject * obj0 = 0 ;
41000 char *kwnames[] = {
41001 (char *) "self", NULL
41002 };
41003
41004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41006 if (SWIG_arg_fail(1)) SWIG_fail;
41007 {
41008 PyThreadState* __tstate = wxPyBeginAllowThreads();
41009 result = (int)(arg1)->GetRows();
41010
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = SWIG_From_int((int)(result));
41016 }
41017 return resultobj;
41018 fail:
41019 return NULL;
41020 }
41021
41022
41023 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41024 PyObject *resultobj;
41025 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41026 int result;
41027 PyObject * obj0 = 0 ;
41028 char *kwnames[] = {
41029 (char *) "self", NULL
41030 };
41031
41032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41034 if (SWIG_arg_fail(1)) SWIG_fail;
41035 {
41036 PyThreadState* __tstate = wxPyBeginAllowThreads();
41037 result = (int)(arg1)->GetVGap();
41038
41039 wxPyEndAllowThreads(__tstate);
41040 if (PyErr_Occurred()) SWIG_fail;
41041 }
41042 {
41043 resultobj = SWIG_From_int((int)(result));
41044 }
41045 return resultobj;
41046 fail:
41047 return NULL;
41048 }
41049
41050
41051 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41052 PyObject *resultobj;
41053 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41054 int result;
41055 PyObject * obj0 = 0 ;
41056 char *kwnames[] = {
41057 (char *) "self", NULL
41058 };
41059
41060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41062 if (SWIG_arg_fail(1)) SWIG_fail;
41063 {
41064 PyThreadState* __tstate = wxPyBeginAllowThreads();
41065 result = (int)(arg1)->GetHGap();
41066
41067 wxPyEndAllowThreads(__tstate);
41068 if (PyErr_Occurred()) SWIG_fail;
41069 }
41070 {
41071 resultobj = SWIG_From_int((int)(result));
41072 }
41073 return resultobj;
41074 fail:
41075 return NULL;
41076 }
41077
41078
41079 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41080 PyObject *obj;
41081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41082 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41083 Py_INCREF(obj);
41084 return Py_BuildValue((char *)"");
41085 }
41086 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41087 PyObject *resultobj;
41088 int arg1 = (int) 1 ;
41089 int arg2 = (int) 0 ;
41090 int arg3 = (int) 0 ;
41091 int arg4 = (int) 0 ;
41092 wxFlexGridSizer *result;
41093 PyObject * obj0 = 0 ;
41094 PyObject * obj1 = 0 ;
41095 PyObject * obj2 = 0 ;
41096 PyObject * obj3 = 0 ;
41097 char *kwnames[] = {
41098 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41099 };
41100
41101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41102 if (obj0) {
41103 {
41104 arg1 = (int)(SWIG_As_int(obj0));
41105 if (SWIG_arg_fail(1)) SWIG_fail;
41106 }
41107 }
41108 if (obj1) {
41109 {
41110 arg2 = (int)(SWIG_As_int(obj1));
41111 if (SWIG_arg_fail(2)) SWIG_fail;
41112 }
41113 }
41114 if (obj2) {
41115 {
41116 arg3 = (int)(SWIG_As_int(obj2));
41117 if (SWIG_arg_fail(3)) SWIG_fail;
41118 }
41119 }
41120 if (obj3) {
41121 {
41122 arg4 = (int)(SWIG_As_int(obj3));
41123 if (SWIG_arg_fail(4)) SWIG_fail;
41124 }
41125 }
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41129
41130 wxPyEndAllowThreads(__tstate);
41131 if (PyErr_Occurred()) SWIG_fail;
41132 }
41133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41134 return resultobj;
41135 fail:
41136 return NULL;
41137 }
41138
41139
41140 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj;
41142 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41143 size_t arg2 ;
41144 int arg3 = (int) 0 ;
41145 PyObject * obj0 = 0 ;
41146 PyObject * obj1 = 0 ;
41147 PyObject * obj2 = 0 ;
41148 char *kwnames[] = {
41149 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41150 };
41151
41152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41154 if (SWIG_arg_fail(1)) SWIG_fail;
41155 {
41156 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41157 if (SWIG_arg_fail(2)) SWIG_fail;
41158 }
41159 if (obj2) {
41160 {
41161 arg3 = (int)(SWIG_As_int(obj2));
41162 if (SWIG_arg_fail(3)) SWIG_fail;
41163 }
41164 }
41165 {
41166 PyThreadState* __tstate = wxPyBeginAllowThreads();
41167 (arg1)->AddGrowableRow(arg2,arg3);
41168
41169 wxPyEndAllowThreads(__tstate);
41170 if (PyErr_Occurred()) SWIG_fail;
41171 }
41172 Py_INCREF(Py_None); resultobj = Py_None;
41173 return resultobj;
41174 fail:
41175 return NULL;
41176 }
41177
41178
41179 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41180 PyObject *resultobj;
41181 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41182 size_t arg2 ;
41183 PyObject * obj0 = 0 ;
41184 PyObject * obj1 = 0 ;
41185 char *kwnames[] = {
41186 (char *) "self",(char *) "idx", NULL
41187 };
41188
41189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41191 if (SWIG_arg_fail(1)) SWIG_fail;
41192 {
41193 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41194 if (SWIG_arg_fail(2)) SWIG_fail;
41195 }
41196 {
41197 PyThreadState* __tstate = wxPyBeginAllowThreads();
41198 (arg1)->RemoveGrowableRow(arg2);
41199
41200 wxPyEndAllowThreads(__tstate);
41201 if (PyErr_Occurred()) SWIG_fail;
41202 }
41203 Py_INCREF(Py_None); resultobj = Py_None;
41204 return resultobj;
41205 fail:
41206 return NULL;
41207 }
41208
41209
41210 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41211 PyObject *resultobj;
41212 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41213 size_t arg2 ;
41214 int arg3 = (int) 0 ;
41215 PyObject * obj0 = 0 ;
41216 PyObject * obj1 = 0 ;
41217 PyObject * obj2 = 0 ;
41218 char *kwnames[] = {
41219 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41220 };
41221
41222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41224 if (SWIG_arg_fail(1)) SWIG_fail;
41225 {
41226 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41227 if (SWIG_arg_fail(2)) SWIG_fail;
41228 }
41229 if (obj2) {
41230 {
41231 arg3 = (int)(SWIG_As_int(obj2));
41232 if (SWIG_arg_fail(3)) SWIG_fail;
41233 }
41234 }
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 (arg1)->AddGrowableCol(arg2,arg3);
41238
41239 wxPyEndAllowThreads(__tstate);
41240 if (PyErr_Occurred()) SWIG_fail;
41241 }
41242 Py_INCREF(Py_None); resultobj = Py_None;
41243 return resultobj;
41244 fail:
41245 return NULL;
41246 }
41247
41248
41249 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41250 PyObject *resultobj;
41251 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41252 size_t arg2 ;
41253 PyObject * obj0 = 0 ;
41254 PyObject * obj1 = 0 ;
41255 char *kwnames[] = {
41256 (char *) "self",(char *) "idx", NULL
41257 };
41258
41259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41261 if (SWIG_arg_fail(1)) SWIG_fail;
41262 {
41263 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41264 if (SWIG_arg_fail(2)) SWIG_fail;
41265 }
41266 {
41267 PyThreadState* __tstate = wxPyBeginAllowThreads();
41268 (arg1)->RemoveGrowableCol(arg2);
41269
41270 wxPyEndAllowThreads(__tstate);
41271 if (PyErr_Occurred()) SWIG_fail;
41272 }
41273 Py_INCREF(Py_None); resultobj = Py_None;
41274 return resultobj;
41275 fail:
41276 return NULL;
41277 }
41278
41279
41280 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41281 PyObject *resultobj;
41282 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41283 int arg2 ;
41284 PyObject * obj0 = 0 ;
41285 PyObject * obj1 = 0 ;
41286 char *kwnames[] = {
41287 (char *) "self",(char *) "direction", NULL
41288 };
41289
41290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41292 if (SWIG_arg_fail(1)) SWIG_fail;
41293 {
41294 arg2 = (int)(SWIG_As_int(obj1));
41295 if (SWIG_arg_fail(2)) SWIG_fail;
41296 }
41297 {
41298 PyThreadState* __tstate = wxPyBeginAllowThreads();
41299 (arg1)->SetFlexibleDirection(arg2);
41300
41301 wxPyEndAllowThreads(__tstate);
41302 if (PyErr_Occurred()) SWIG_fail;
41303 }
41304 Py_INCREF(Py_None); resultobj = Py_None;
41305 return resultobj;
41306 fail:
41307 return NULL;
41308 }
41309
41310
41311 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41312 PyObject *resultobj;
41313 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41314 int result;
41315 PyObject * obj0 = 0 ;
41316 char *kwnames[] = {
41317 (char *) "self", NULL
41318 };
41319
41320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41322 if (SWIG_arg_fail(1)) SWIG_fail;
41323 {
41324 PyThreadState* __tstate = wxPyBeginAllowThreads();
41325 result = (int)(arg1)->GetFlexibleDirection();
41326
41327 wxPyEndAllowThreads(__tstate);
41328 if (PyErr_Occurred()) SWIG_fail;
41329 }
41330 {
41331 resultobj = SWIG_From_int((int)(result));
41332 }
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41340 PyObject *resultobj;
41341 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41342 wxFlexSizerGrowMode arg2 ;
41343 PyObject * obj0 = 0 ;
41344 PyObject * obj1 = 0 ;
41345 char *kwnames[] = {
41346 (char *) "self",(char *) "mode", NULL
41347 };
41348
41349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41351 if (SWIG_arg_fail(1)) SWIG_fail;
41352 {
41353 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41354 if (SWIG_arg_fail(2)) SWIG_fail;
41355 }
41356 {
41357 PyThreadState* __tstate = wxPyBeginAllowThreads();
41358 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41359
41360 wxPyEndAllowThreads(__tstate);
41361 if (PyErr_Occurred()) SWIG_fail;
41362 }
41363 Py_INCREF(Py_None); resultobj = Py_None;
41364 return resultobj;
41365 fail:
41366 return NULL;
41367 }
41368
41369
41370 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41371 PyObject *resultobj;
41372 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41373 wxFlexSizerGrowMode result;
41374 PyObject * obj0 = 0 ;
41375 char *kwnames[] = {
41376 (char *) "self", NULL
41377 };
41378
41379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41381 if (SWIG_arg_fail(1)) SWIG_fail;
41382 {
41383 PyThreadState* __tstate = wxPyBeginAllowThreads();
41384 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41385
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 resultobj = SWIG_From_int((result));
41390 return resultobj;
41391 fail:
41392 return NULL;
41393 }
41394
41395
41396 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41397 PyObject *resultobj;
41398 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41399 wxArrayInt *result;
41400 PyObject * obj0 = 0 ;
41401 char *kwnames[] = {
41402 (char *) "self", NULL
41403 };
41404
41405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41407 if (SWIG_arg_fail(1)) SWIG_fail;
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 {
41411 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41412 result = (wxArrayInt *) &_result_ref;
41413 }
41414
41415 wxPyEndAllowThreads(__tstate);
41416 if (PyErr_Occurred()) SWIG_fail;
41417 }
41418 {
41419 resultobj = PyList_New(0);
41420 size_t idx;
41421 for (idx = 0; idx < result->GetCount(); idx += 1) {
41422 PyObject* val = PyInt_FromLong( result->Item(idx) );
41423 PyList_Append(resultobj, val);
41424 Py_DECREF(val);
41425 }
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41434 PyObject *resultobj;
41435 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41436 wxArrayInt *result;
41437 PyObject * obj0 = 0 ;
41438 char *kwnames[] = {
41439 (char *) "self", NULL
41440 };
41441
41442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41444 if (SWIG_arg_fail(1)) SWIG_fail;
41445 {
41446 PyThreadState* __tstate = wxPyBeginAllowThreads();
41447 {
41448 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41449 result = (wxArrayInt *) &_result_ref;
41450 }
41451
41452 wxPyEndAllowThreads(__tstate);
41453 if (PyErr_Occurred()) SWIG_fail;
41454 }
41455 {
41456 resultobj = PyList_New(0);
41457 size_t idx;
41458 for (idx = 0; idx < result->GetCount(); idx += 1) {
41459 PyObject* val = PyInt_FromLong( result->Item(idx) );
41460 PyList_Append(resultobj, val);
41461 Py_DECREF(val);
41462 }
41463 }
41464 return resultobj;
41465 fail:
41466 return NULL;
41467 }
41468
41469
41470 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41471 PyObject *obj;
41472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41473 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41474 Py_INCREF(obj);
41475 return Py_BuildValue((char *)"");
41476 }
41477 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41478 PyObject *resultobj;
41479 wxStdDialogButtonSizer *result;
41480 char *kwnames[] = {
41481 NULL
41482 };
41483
41484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41485 {
41486 PyThreadState* __tstate = wxPyBeginAllowThreads();
41487 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41488
41489 wxPyEndAllowThreads(__tstate);
41490 if (PyErr_Occurred()) SWIG_fail;
41491 }
41492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41493 return resultobj;
41494 fail:
41495 return NULL;
41496 }
41497
41498
41499 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41500 PyObject *resultobj;
41501 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41502 wxButton *arg2 = (wxButton *) 0 ;
41503 PyObject * obj0 = 0 ;
41504 PyObject * obj1 = 0 ;
41505 char *kwnames[] = {
41506 (char *) "self",(char *) "button", NULL
41507 };
41508
41509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41511 if (SWIG_arg_fail(1)) SWIG_fail;
41512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41513 if (SWIG_arg_fail(2)) SWIG_fail;
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 (arg1)->AddButton(arg2);
41517
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 Py_INCREF(Py_None); resultobj = Py_None;
41522 return resultobj;
41523 fail:
41524 return NULL;
41525 }
41526
41527
41528 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41529 PyObject *resultobj;
41530 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41531 PyObject * obj0 = 0 ;
41532 char *kwnames[] = {
41533 (char *) "self", NULL
41534 };
41535
41536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41538 if (SWIG_arg_fail(1)) SWIG_fail;
41539 {
41540 PyThreadState* __tstate = wxPyBeginAllowThreads();
41541 (arg1)->Realize();
41542
41543 wxPyEndAllowThreads(__tstate);
41544 if (PyErr_Occurred()) SWIG_fail;
41545 }
41546 Py_INCREF(Py_None); resultobj = Py_None;
41547 return resultobj;
41548 fail:
41549 return NULL;
41550 }
41551
41552
41553 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41554 PyObject *resultobj;
41555 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41556 wxButton *arg2 = (wxButton *) 0 ;
41557 PyObject * obj0 = 0 ;
41558 PyObject * obj1 = 0 ;
41559 char *kwnames[] = {
41560 (char *) "self",(char *) "button", NULL
41561 };
41562
41563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41565 if (SWIG_arg_fail(1)) SWIG_fail;
41566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41567 if (SWIG_arg_fail(2)) SWIG_fail;
41568 {
41569 PyThreadState* __tstate = wxPyBeginAllowThreads();
41570 (arg1)->SetAffirmativeButton(arg2);
41571
41572 wxPyEndAllowThreads(__tstate);
41573 if (PyErr_Occurred()) SWIG_fail;
41574 }
41575 Py_INCREF(Py_None); resultobj = Py_None;
41576 return resultobj;
41577 fail:
41578 return NULL;
41579 }
41580
41581
41582 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41583 PyObject *resultobj;
41584 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41585 wxButton *arg2 = (wxButton *) 0 ;
41586 PyObject * obj0 = 0 ;
41587 PyObject * obj1 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self",(char *) "button", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41596 if (SWIG_arg_fail(2)) SWIG_fail;
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 (arg1)->SetNegativeButton(arg2);
41600
41601 wxPyEndAllowThreads(__tstate);
41602 if (PyErr_Occurred()) SWIG_fail;
41603 }
41604 Py_INCREF(Py_None); resultobj = Py_None;
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41612 PyObject *resultobj;
41613 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41614 wxButton *arg2 = (wxButton *) 0 ;
41615 PyObject * obj0 = 0 ;
41616 PyObject * obj1 = 0 ;
41617 char *kwnames[] = {
41618 (char *) "self",(char *) "button", NULL
41619 };
41620
41621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41623 if (SWIG_arg_fail(1)) SWIG_fail;
41624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41625 if (SWIG_arg_fail(2)) SWIG_fail;
41626 {
41627 PyThreadState* __tstate = wxPyBeginAllowThreads();
41628 (arg1)->SetCancelButton(arg2);
41629
41630 wxPyEndAllowThreads(__tstate);
41631 if (PyErr_Occurred()) SWIG_fail;
41632 }
41633 Py_INCREF(Py_None); resultobj = Py_None;
41634 return resultobj;
41635 fail:
41636 return NULL;
41637 }
41638
41639
41640 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41641 PyObject *resultobj;
41642 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41643 wxButton *result;
41644 PyObject * obj0 = 0 ;
41645 char *kwnames[] = {
41646 (char *) "self", NULL
41647 };
41648
41649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41651 if (SWIG_arg_fail(1)) SWIG_fail;
41652 {
41653 PyThreadState* __tstate = wxPyBeginAllowThreads();
41654 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41655
41656 wxPyEndAllowThreads(__tstate);
41657 if (PyErr_Occurred()) SWIG_fail;
41658 }
41659 {
41660 resultobj = wxPyMake_wxObject(result, 0);
41661 }
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41669 PyObject *resultobj;
41670 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41671 wxButton *result;
41672 PyObject * obj0 = 0 ;
41673 char *kwnames[] = {
41674 (char *) "self", NULL
41675 };
41676
41677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41679 if (SWIG_arg_fail(1)) SWIG_fail;
41680 {
41681 PyThreadState* __tstate = wxPyBeginAllowThreads();
41682 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41683
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 {
41688 resultobj = wxPyMake_wxObject(result, 0);
41689 }
41690 return resultobj;
41691 fail:
41692 return NULL;
41693 }
41694
41695
41696 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41697 PyObject *resultobj;
41698 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41699 wxButton *result;
41700 PyObject * obj0 = 0 ;
41701 char *kwnames[] = {
41702 (char *) "self", NULL
41703 };
41704
41705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41707 if (SWIG_arg_fail(1)) SWIG_fail;
41708 {
41709 PyThreadState* __tstate = wxPyBeginAllowThreads();
41710 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41711
41712 wxPyEndAllowThreads(__tstate);
41713 if (PyErr_Occurred()) SWIG_fail;
41714 }
41715 {
41716 resultobj = wxPyMake_wxObject(result, 0);
41717 }
41718 return resultobj;
41719 fail:
41720 return NULL;
41721 }
41722
41723
41724 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41725 PyObject *resultobj;
41726 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41727 wxButton *result;
41728 PyObject * obj0 = 0 ;
41729 char *kwnames[] = {
41730 (char *) "self", NULL
41731 };
41732
41733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41735 if (SWIG_arg_fail(1)) SWIG_fail;
41736 {
41737 PyThreadState* __tstate = wxPyBeginAllowThreads();
41738 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41739
41740 wxPyEndAllowThreads(__tstate);
41741 if (PyErr_Occurred()) SWIG_fail;
41742 }
41743 {
41744 resultobj = wxPyMake_wxObject(result, 0);
41745 }
41746 return resultobj;
41747 fail:
41748 return NULL;
41749 }
41750
41751
41752 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj;
41754 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41755 wxButton *result;
41756 PyObject * obj0 = 0 ;
41757 char *kwnames[] = {
41758 (char *) "self", NULL
41759 };
41760
41761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41763 if (SWIG_arg_fail(1)) SWIG_fail;
41764 {
41765 PyThreadState* __tstate = wxPyBeginAllowThreads();
41766 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41767
41768 wxPyEndAllowThreads(__tstate);
41769 if (PyErr_Occurred()) SWIG_fail;
41770 }
41771 {
41772 resultobj = wxPyMake_wxObject(result, 0);
41773 }
41774 return resultobj;
41775 fail:
41776 return NULL;
41777 }
41778
41779
41780 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41781 PyObject *obj;
41782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41783 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41784 Py_INCREF(obj);
41785 return Py_BuildValue((char *)"");
41786 }
41787 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41788 PyObject *resultobj;
41789 int arg1 = (int) 0 ;
41790 int arg2 = (int) 0 ;
41791 wxGBPosition *result;
41792 PyObject * obj0 = 0 ;
41793 PyObject * obj1 = 0 ;
41794 char *kwnames[] = {
41795 (char *) "row",(char *) "col", NULL
41796 };
41797
41798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41799 if (obj0) {
41800 {
41801 arg1 = (int)(SWIG_As_int(obj0));
41802 if (SWIG_arg_fail(1)) SWIG_fail;
41803 }
41804 }
41805 if (obj1) {
41806 {
41807 arg2 = (int)(SWIG_As_int(obj1));
41808 if (SWIG_arg_fail(2)) SWIG_fail;
41809 }
41810 }
41811 {
41812 PyThreadState* __tstate = wxPyBeginAllowThreads();
41813 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41814
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41819 return resultobj;
41820 fail:
41821 return NULL;
41822 }
41823
41824
41825 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41826 PyObject *resultobj;
41827 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41828 int result;
41829 PyObject * obj0 = 0 ;
41830 char *kwnames[] = {
41831 (char *) "self", NULL
41832 };
41833
41834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41836 if (SWIG_arg_fail(1)) SWIG_fail;
41837 {
41838 PyThreadState* __tstate = wxPyBeginAllowThreads();
41839 result = (int)((wxGBPosition const *)arg1)->GetRow();
41840
41841 wxPyEndAllowThreads(__tstate);
41842 if (PyErr_Occurred()) SWIG_fail;
41843 }
41844 {
41845 resultobj = SWIG_From_int((int)(result));
41846 }
41847 return resultobj;
41848 fail:
41849 return NULL;
41850 }
41851
41852
41853 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41854 PyObject *resultobj;
41855 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41856 int result;
41857 PyObject * obj0 = 0 ;
41858 char *kwnames[] = {
41859 (char *) "self", NULL
41860 };
41861
41862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41864 if (SWIG_arg_fail(1)) SWIG_fail;
41865 {
41866 PyThreadState* __tstate = wxPyBeginAllowThreads();
41867 result = (int)((wxGBPosition const *)arg1)->GetCol();
41868
41869 wxPyEndAllowThreads(__tstate);
41870 if (PyErr_Occurred()) SWIG_fail;
41871 }
41872 {
41873 resultobj = SWIG_From_int((int)(result));
41874 }
41875 return resultobj;
41876 fail:
41877 return NULL;
41878 }
41879
41880
41881 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41882 PyObject *resultobj;
41883 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41884 int arg2 ;
41885 PyObject * obj0 = 0 ;
41886 PyObject * obj1 = 0 ;
41887 char *kwnames[] = {
41888 (char *) "self",(char *) "row", NULL
41889 };
41890
41891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41893 if (SWIG_arg_fail(1)) SWIG_fail;
41894 {
41895 arg2 = (int)(SWIG_As_int(obj1));
41896 if (SWIG_arg_fail(2)) SWIG_fail;
41897 }
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 (arg1)->SetRow(arg2);
41901
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 Py_INCREF(Py_None); resultobj = Py_None;
41906 return resultobj;
41907 fail:
41908 return NULL;
41909 }
41910
41911
41912 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41913 PyObject *resultobj;
41914 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41915 int arg2 ;
41916 PyObject * obj0 = 0 ;
41917 PyObject * obj1 = 0 ;
41918 char *kwnames[] = {
41919 (char *) "self",(char *) "col", NULL
41920 };
41921
41922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41924 if (SWIG_arg_fail(1)) SWIG_fail;
41925 {
41926 arg2 = (int)(SWIG_As_int(obj1));
41927 if (SWIG_arg_fail(2)) SWIG_fail;
41928 }
41929 {
41930 PyThreadState* __tstate = wxPyBeginAllowThreads();
41931 (arg1)->SetCol(arg2);
41932
41933 wxPyEndAllowThreads(__tstate);
41934 if (PyErr_Occurred()) SWIG_fail;
41935 }
41936 Py_INCREF(Py_None); resultobj = Py_None;
41937 return resultobj;
41938 fail:
41939 return NULL;
41940 }
41941
41942
41943 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41944 PyObject *resultobj;
41945 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41946 wxGBPosition *arg2 = 0 ;
41947 bool result;
41948 wxGBPosition temp2 ;
41949 PyObject * obj0 = 0 ;
41950 PyObject * obj1 = 0 ;
41951 char *kwnames[] = {
41952 (char *) "self",(char *) "other", NULL
41953 };
41954
41955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41957 if (SWIG_arg_fail(1)) SWIG_fail;
41958 {
41959 arg2 = &temp2;
41960 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41961 }
41962 {
41963 PyThreadState* __tstate = wxPyBeginAllowThreads();
41964 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41965
41966 wxPyEndAllowThreads(__tstate);
41967 if (PyErr_Occurred()) SWIG_fail;
41968 }
41969 {
41970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41971 }
41972 return resultobj;
41973 fail:
41974 return NULL;
41975 }
41976
41977
41978 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41979 PyObject *resultobj;
41980 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41981 wxGBPosition *arg2 = 0 ;
41982 bool result;
41983 wxGBPosition temp2 ;
41984 PyObject * obj0 = 0 ;
41985 PyObject * obj1 = 0 ;
41986 char *kwnames[] = {
41987 (char *) "self",(char *) "other", NULL
41988 };
41989
41990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41992 if (SWIG_arg_fail(1)) SWIG_fail;
41993 {
41994 arg2 = &temp2;
41995 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41996 }
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42000
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 {
42005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42006 }
42007 return resultobj;
42008 fail:
42009 return NULL;
42010 }
42011
42012
42013 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42014 PyObject *resultobj;
42015 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42016 int arg2 = (int) 0 ;
42017 int arg3 = (int) 0 ;
42018 PyObject * obj0 = 0 ;
42019 PyObject * obj1 = 0 ;
42020 PyObject * obj2 = 0 ;
42021 char *kwnames[] = {
42022 (char *) "self",(char *) "row",(char *) "col", NULL
42023 };
42024
42025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42027 if (SWIG_arg_fail(1)) SWIG_fail;
42028 if (obj1) {
42029 {
42030 arg2 = (int)(SWIG_As_int(obj1));
42031 if (SWIG_arg_fail(2)) SWIG_fail;
42032 }
42033 }
42034 if (obj2) {
42035 {
42036 arg3 = (int)(SWIG_As_int(obj2));
42037 if (SWIG_arg_fail(3)) SWIG_fail;
42038 }
42039 }
42040 {
42041 PyThreadState* __tstate = wxPyBeginAllowThreads();
42042 wxGBPosition_Set(arg1,arg2,arg3);
42043
42044 wxPyEndAllowThreads(__tstate);
42045 if (PyErr_Occurred()) SWIG_fail;
42046 }
42047 Py_INCREF(Py_None); resultobj = Py_None;
42048 return resultobj;
42049 fail:
42050 return NULL;
42051 }
42052
42053
42054 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42055 PyObject *resultobj;
42056 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42057 PyObject *result;
42058 PyObject * obj0 = 0 ;
42059 char *kwnames[] = {
42060 (char *) "self", NULL
42061 };
42062
42063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42065 if (SWIG_arg_fail(1)) SWIG_fail;
42066 {
42067 PyThreadState* __tstate = wxPyBeginAllowThreads();
42068 result = (PyObject *)wxGBPosition_Get(arg1);
42069
42070 wxPyEndAllowThreads(__tstate);
42071 if (PyErr_Occurred()) SWIG_fail;
42072 }
42073 resultobj = result;
42074 return resultobj;
42075 fail:
42076 return NULL;
42077 }
42078
42079
42080 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42081 PyObject *obj;
42082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42083 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42084 Py_INCREF(obj);
42085 return Py_BuildValue((char *)"");
42086 }
42087 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42088 PyObject *resultobj;
42089 int arg1 = (int) 1 ;
42090 int arg2 = (int) 1 ;
42091 wxGBSpan *result;
42092 PyObject * obj0 = 0 ;
42093 PyObject * obj1 = 0 ;
42094 char *kwnames[] = {
42095 (char *) "rowspan",(char *) "colspan", NULL
42096 };
42097
42098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42099 if (obj0) {
42100 {
42101 arg1 = (int)(SWIG_As_int(obj0));
42102 if (SWIG_arg_fail(1)) SWIG_fail;
42103 }
42104 }
42105 if (obj1) {
42106 {
42107 arg2 = (int)(SWIG_As_int(obj1));
42108 if (SWIG_arg_fail(2)) SWIG_fail;
42109 }
42110 }
42111 {
42112 PyThreadState* __tstate = wxPyBeginAllowThreads();
42113 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42114
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42119 return resultobj;
42120 fail:
42121 return NULL;
42122 }
42123
42124
42125 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42126 PyObject *resultobj;
42127 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42128 int result;
42129 PyObject * obj0 = 0 ;
42130 char *kwnames[] = {
42131 (char *) "self", NULL
42132 };
42133
42134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42136 if (SWIG_arg_fail(1)) SWIG_fail;
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42140
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 {
42145 resultobj = SWIG_From_int((int)(result));
42146 }
42147 return resultobj;
42148 fail:
42149 return NULL;
42150 }
42151
42152
42153 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42154 PyObject *resultobj;
42155 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42156 int result;
42157 PyObject * obj0 = 0 ;
42158 char *kwnames[] = {
42159 (char *) "self", NULL
42160 };
42161
42162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42164 if (SWIG_arg_fail(1)) SWIG_fail;
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42168
42169 wxPyEndAllowThreads(__tstate);
42170 if (PyErr_Occurred()) SWIG_fail;
42171 }
42172 {
42173 resultobj = SWIG_From_int((int)(result));
42174 }
42175 return resultobj;
42176 fail:
42177 return NULL;
42178 }
42179
42180
42181 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42182 PyObject *resultobj;
42183 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42184 int arg2 ;
42185 PyObject * obj0 = 0 ;
42186 PyObject * obj1 = 0 ;
42187 char *kwnames[] = {
42188 (char *) "self",(char *) "rowspan", NULL
42189 };
42190
42191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42193 if (SWIG_arg_fail(1)) SWIG_fail;
42194 {
42195 arg2 = (int)(SWIG_As_int(obj1));
42196 if (SWIG_arg_fail(2)) SWIG_fail;
42197 }
42198 {
42199 PyThreadState* __tstate = wxPyBeginAllowThreads();
42200 (arg1)->SetRowspan(arg2);
42201
42202 wxPyEndAllowThreads(__tstate);
42203 if (PyErr_Occurred()) SWIG_fail;
42204 }
42205 Py_INCREF(Py_None); resultobj = Py_None;
42206 return resultobj;
42207 fail:
42208 return NULL;
42209 }
42210
42211
42212 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42213 PyObject *resultobj;
42214 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42215 int arg2 ;
42216 PyObject * obj0 = 0 ;
42217 PyObject * obj1 = 0 ;
42218 char *kwnames[] = {
42219 (char *) "self",(char *) "colspan", NULL
42220 };
42221
42222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42224 if (SWIG_arg_fail(1)) SWIG_fail;
42225 {
42226 arg2 = (int)(SWIG_As_int(obj1));
42227 if (SWIG_arg_fail(2)) SWIG_fail;
42228 }
42229 {
42230 PyThreadState* __tstate = wxPyBeginAllowThreads();
42231 (arg1)->SetColspan(arg2);
42232
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 Py_INCREF(Py_None); resultobj = Py_None;
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42244 PyObject *resultobj;
42245 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42246 wxGBSpan *arg2 = 0 ;
42247 bool result;
42248 wxGBSpan temp2 ;
42249 PyObject * obj0 = 0 ;
42250 PyObject * obj1 = 0 ;
42251 char *kwnames[] = {
42252 (char *) "self",(char *) "other", NULL
42253 };
42254
42255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42257 if (SWIG_arg_fail(1)) SWIG_fail;
42258 {
42259 arg2 = &temp2;
42260 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42261 }
42262 {
42263 PyThreadState* __tstate = wxPyBeginAllowThreads();
42264 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42265
42266 wxPyEndAllowThreads(__tstate);
42267 if (PyErr_Occurred()) SWIG_fail;
42268 }
42269 {
42270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42271 }
42272 return resultobj;
42273 fail:
42274 return NULL;
42275 }
42276
42277
42278 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42279 PyObject *resultobj;
42280 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42281 wxGBSpan *arg2 = 0 ;
42282 bool result;
42283 wxGBSpan temp2 ;
42284 PyObject * obj0 = 0 ;
42285 PyObject * obj1 = 0 ;
42286 char *kwnames[] = {
42287 (char *) "self",(char *) "other", NULL
42288 };
42289
42290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42292 if (SWIG_arg_fail(1)) SWIG_fail;
42293 {
42294 arg2 = &temp2;
42295 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42296 }
42297 {
42298 PyThreadState* __tstate = wxPyBeginAllowThreads();
42299 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42300
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 {
42305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42306 }
42307 return resultobj;
42308 fail:
42309 return NULL;
42310 }
42311
42312
42313 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42314 PyObject *resultobj;
42315 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42316 int arg2 = (int) 1 ;
42317 int arg3 = (int) 1 ;
42318 PyObject * obj0 = 0 ;
42319 PyObject * obj1 = 0 ;
42320 PyObject * obj2 = 0 ;
42321 char *kwnames[] = {
42322 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42323 };
42324
42325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42327 if (SWIG_arg_fail(1)) SWIG_fail;
42328 if (obj1) {
42329 {
42330 arg2 = (int)(SWIG_As_int(obj1));
42331 if (SWIG_arg_fail(2)) SWIG_fail;
42332 }
42333 }
42334 if (obj2) {
42335 {
42336 arg3 = (int)(SWIG_As_int(obj2));
42337 if (SWIG_arg_fail(3)) SWIG_fail;
42338 }
42339 }
42340 {
42341 PyThreadState* __tstate = wxPyBeginAllowThreads();
42342 wxGBSpan_Set(arg1,arg2,arg3);
42343
42344 wxPyEndAllowThreads(__tstate);
42345 if (PyErr_Occurred()) SWIG_fail;
42346 }
42347 Py_INCREF(Py_None); resultobj = Py_None;
42348 return resultobj;
42349 fail:
42350 return NULL;
42351 }
42352
42353
42354 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42355 PyObject *resultobj;
42356 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42357 PyObject *result;
42358 PyObject * obj0 = 0 ;
42359 char *kwnames[] = {
42360 (char *) "self", NULL
42361 };
42362
42363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42365 if (SWIG_arg_fail(1)) SWIG_fail;
42366 {
42367 PyThreadState* __tstate = wxPyBeginAllowThreads();
42368 result = (PyObject *)wxGBSpan_Get(arg1);
42369
42370 wxPyEndAllowThreads(__tstate);
42371 if (PyErr_Occurred()) SWIG_fail;
42372 }
42373 resultobj = result;
42374 return resultobj;
42375 fail:
42376 return NULL;
42377 }
42378
42379
42380 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42381 PyObject *obj;
42382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42383 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42384 Py_INCREF(obj);
42385 return Py_BuildValue((char *)"");
42386 }
42387 static int _wrap_DefaultSpan_set(PyObject *) {
42388 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42389 return 1;
42390 }
42391
42392
42393 static PyObject *_wrap_DefaultSpan_get(void) {
42394 PyObject *pyobj;
42395
42396 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42397 return pyobj;
42398 }
42399
42400
42401 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42402 PyObject *resultobj;
42403 wxGBSizerItem *result;
42404 char *kwnames[] = {
42405 NULL
42406 };
42407
42408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42409 {
42410 PyThreadState* __tstate = wxPyBeginAllowThreads();
42411 result = (wxGBSizerItem *)new wxGBSizerItem();
42412
42413 wxPyEndAllowThreads(__tstate);
42414 if (PyErr_Occurred()) SWIG_fail;
42415 }
42416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42417 return resultobj;
42418 fail:
42419 return NULL;
42420 }
42421
42422
42423 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42424 PyObject *resultobj;
42425 wxWindow *arg1 = (wxWindow *) 0 ;
42426 wxGBPosition *arg2 = 0 ;
42427 wxGBSpan *arg3 = 0 ;
42428 int arg4 ;
42429 int arg5 ;
42430 PyObject *arg6 = (PyObject *) NULL ;
42431 wxGBSizerItem *result;
42432 wxGBPosition temp2 ;
42433 wxGBSpan temp3 ;
42434 PyObject * obj0 = 0 ;
42435 PyObject * obj1 = 0 ;
42436 PyObject * obj2 = 0 ;
42437 PyObject * obj3 = 0 ;
42438 PyObject * obj4 = 0 ;
42439 PyObject * obj5 = 0 ;
42440 char *kwnames[] = {
42441 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42442 };
42443
42444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42446 if (SWIG_arg_fail(1)) SWIG_fail;
42447 {
42448 arg2 = &temp2;
42449 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42450 }
42451 {
42452 arg3 = &temp3;
42453 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42454 }
42455 {
42456 arg4 = (int)(SWIG_As_int(obj3));
42457 if (SWIG_arg_fail(4)) SWIG_fail;
42458 }
42459 {
42460 arg5 = (int)(SWIG_As_int(obj4));
42461 if (SWIG_arg_fail(5)) SWIG_fail;
42462 }
42463 if (obj5) {
42464 arg6 = obj5;
42465 }
42466 {
42467 PyThreadState* __tstate = wxPyBeginAllowThreads();
42468 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42469
42470 wxPyEndAllowThreads(__tstate);
42471 if (PyErr_Occurred()) SWIG_fail;
42472 }
42473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42474 return resultobj;
42475 fail:
42476 return NULL;
42477 }
42478
42479
42480 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42481 PyObject *resultobj;
42482 wxSizer *arg1 = (wxSizer *) 0 ;
42483 wxGBPosition *arg2 = 0 ;
42484 wxGBSpan *arg3 = 0 ;
42485 int arg4 ;
42486 int arg5 ;
42487 PyObject *arg6 = (PyObject *) NULL ;
42488 wxGBSizerItem *result;
42489 wxGBPosition temp2 ;
42490 wxGBSpan temp3 ;
42491 PyObject * obj0 = 0 ;
42492 PyObject * obj1 = 0 ;
42493 PyObject * obj2 = 0 ;
42494 PyObject * obj3 = 0 ;
42495 PyObject * obj4 = 0 ;
42496 PyObject * obj5 = 0 ;
42497 char *kwnames[] = {
42498 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42499 };
42500
42501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42503 if (SWIG_arg_fail(1)) SWIG_fail;
42504 {
42505 arg2 = &temp2;
42506 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42507 }
42508 {
42509 arg3 = &temp3;
42510 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42511 }
42512 {
42513 arg4 = (int)(SWIG_As_int(obj3));
42514 if (SWIG_arg_fail(4)) SWIG_fail;
42515 }
42516 {
42517 arg5 = (int)(SWIG_As_int(obj4));
42518 if (SWIG_arg_fail(5)) SWIG_fail;
42519 }
42520 if (obj5) {
42521 arg6 = obj5;
42522 }
42523 {
42524 PyThreadState* __tstate = wxPyBeginAllowThreads();
42525 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42526
42527 wxPyEndAllowThreads(__tstate);
42528 if (PyErr_Occurred()) SWIG_fail;
42529 }
42530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42531 return resultobj;
42532 fail:
42533 return NULL;
42534 }
42535
42536
42537 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42538 PyObject *resultobj;
42539 int arg1 ;
42540 int arg2 ;
42541 wxGBPosition *arg3 = 0 ;
42542 wxGBSpan *arg4 = 0 ;
42543 int arg5 ;
42544 int arg6 ;
42545 PyObject *arg7 = (PyObject *) NULL ;
42546 wxGBSizerItem *result;
42547 wxGBPosition temp3 ;
42548 wxGBSpan temp4 ;
42549 PyObject * obj0 = 0 ;
42550 PyObject * obj1 = 0 ;
42551 PyObject * obj2 = 0 ;
42552 PyObject * obj3 = 0 ;
42553 PyObject * obj4 = 0 ;
42554 PyObject * obj5 = 0 ;
42555 PyObject * obj6 = 0 ;
42556 char *kwnames[] = {
42557 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42558 };
42559
42560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42561 {
42562 arg1 = (int)(SWIG_As_int(obj0));
42563 if (SWIG_arg_fail(1)) SWIG_fail;
42564 }
42565 {
42566 arg2 = (int)(SWIG_As_int(obj1));
42567 if (SWIG_arg_fail(2)) SWIG_fail;
42568 }
42569 {
42570 arg3 = &temp3;
42571 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42572 }
42573 {
42574 arg4 = &temp4;
42575 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42576 }
42577 {
42578 arg5 = (int)(SWIG_As_int(obj4));
42579 if (SWIG_arg_fail(5)) SWIG_fail;
42580 }
42581 {
42582 arg6 = (int)(SWIG_As_int(obj5));
42583 if (SWIG_arg_fail(6)) SWIG_fail;
42584 }
42585 if (obj6) {
42586 arg7 = obj6;
42587 }
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42591
42592 wxPyEndAllowThreads(__tstate);
42593 if (PyErr_Occurred()) SWIG_fail;
42594 }
42595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42596 return resultobj;
42597 fail:
42598 return NULL;
42599 }
42600
42601
42602 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42603 PyObject *resultobj;
42604 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42605 wxGBPosition result;
42606 PyObject * obj0 = 0 ;
42607 char *kwnames[] = {
42608 (char *) "self", NULL
42609 };
42610
42611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42613 if (SWIG_arg_fail(1)) SWIG_fail;
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = ((wxGBSizerItem const *)arg1)->GetPos();
42617
42618 wxPyEndAllowThreads(__tstate);
42619 if (PyErr_Occurred()) SWIG_fail;
42620 }
42621 {
42622 wxGBPosition * resultptr;
42623 resultptr = new wxGBPosition((wxGBPosition &)(result));
42624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42625 }
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42633 PyObject *resultobj;
42634 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42635 wxGBSpan result;
42636 PyObject * obj0 = 0 ;
42637 char *kwnames[] = {
42638 (char *) "self", NULL
42639 };
42640
42641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42643 if (SWIG_arg_fail(1)) SWIG_fail;
42644 {
42645 PyThreadState* __tstate = wxPyBeginAllowThreads();
42646 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42647
42648 wxPyEndAllowThreads(__tstate);
42649 if (PyErr_Occurred()) SWIG_fail;
42650 }
42651 {
42652 wxGBSpan * resultptr;
42653 resultptr = new wxGBSpan((wxGBSpan &)(result));
42654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42655 }
42656 return resultobj;
42657 fail:
42658 return NULL;
42659 }
42660
42661
42662 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42663 PyObject *resultobj;
42664 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42665 wxGBPosition *arg2 = 0 ;
42666 bool result;
42667 wxGBPosition temp2 ;
42668 PyObject * obj0 = 0 ;
42669 PyObject * obj1 = 0 ;
42670 char *kwnames[] = {
42671 (char *) "self",(char *) "pos", NULL
42672 };
42673
42674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42676 if (SWIG_arg_fail(1)) SWIG_fail;
42677 {
42678 arg2 = &temp2;
42679 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42680 }
42681 {
42682 PyThreadState* __tstate = wxPyBeginAllowThreads();
42683 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42684
42685 wxPyEndAllowThreads(__tstate);
42686 if (PyErr_Occurred()) SWIG_fail;
42687 }
42688 {
42689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42690 }
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42698 PyObject *resultobj;
42699 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42700 wxGBSpan *arg2 = 0 ;
42701 bool result;
42702 wxGBSpan temp2 ;
42703 PyObject * obj0 = 0 ;
42704 PyObject * obj1 = 0 ;
42705 char *kwnames[] = {
42706 (char *) "self",(char *) "span", NULL
42707 };
42708
42709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42711 if (SWIG_arg_fail(1)) SWIG_fail;
42712 {
42713 arg2 = &temp2;
42714 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42715 }
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42719
42720 wxPyEndAllowThreads(__tstate);
42721 if (PyErr_Occurred()) SWIG_fail;
42722 }
42723 {
42724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42725 }
42726 return resultobj;
42727 fail:
42728 return NULL;
42729 }
42730
42731
42732 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42733 PyObject *resultobj;
42734 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42735 wxGBSizerItem *arg2 = 0 ;
42736 bool result;
42737 PyObject * obj0 = 0 ;
42738 PyObject * obj1 = 0 ;
42739 char *kwnames[] = {
42740 (char *) "self",(char *) "other", NULL
42741 };
42742
42743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42745 if (SWIG_arg_fail(1)) SWIG_fail;
42746 {
42747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42748 if (SWIG_arg_fail(2)) SWIG_fail;
42749 if (arg2 == NULL) {
42750 SWIG_null_ref("wxGBSizerItem");
42751 }
42752 if (SWIG_arg_fail(2)) SWIG_fail;
42753 }
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42757
42758 wxPyEndAllowThreads(__tstate);
42759 if (PyErr_Occurred()) SWIG_fail;
42760 }
42761 {
42762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42763 }
42764 return resultobj;
42765 fail:
42766 return NULL;
42767 }
42768
42769
42770 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42771 PyObject *resultobj;
42772 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42773 wxGBPosition *arg2 = 0 ;
42774 wxGBSpan *arg3 = 0 ;
42775 bool result;
42776 wxGBPosition temp2 ;
42777 wxGBSpan temp3 ;
42778 PyObject * obj0 = 0 ;
42779 PyObject * obj1 = 0 ;
42780 PyObject * obj2 = 0 ;
42781 char *kwnames[] = {
42782 (char *) "self",(char *) "pos",(char *) "span", NULL
42783 };
42784
42785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42787 if (SWIG_arg_fail(1)) SWIG_fail;
42788 {
42789 arg2 = &temp2;
42790 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42791 }
42792 {
42793 arg3 = &temp3;
42794 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42795 }
42796 {
42797 PyThreadState* __tstate = wxPyBeginAllowThreads();
42798 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42799
42800 wxPyEndAllowThreads(__tstate);
42801 if (PyErr_Occurred()) SWIG_fail;
42802 }
42803 {
42804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42805 }
42806 return resultobj;
42807 fail:
42808 return NULL;
42809 }
42810
42811
42812 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42813 PyObject *resultobj;
42814 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42815 wxGBPosition result;
42816 PyObject * obj0 = 0 ;
42817 char *kwnames[] = {
42818 (char *) "self", NULL
42819 };
42820
42821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42823 if (SWIG_arg_fail(1)) SWIG_fail;
42824 {
42825 PyThreadState* __tstate = wxPyBeginAllowThreads();
42826 result = wxGBSizerItem_GetEndPos(arg1);
42827
42828 wxPyEndAllowThreads(__tstate);
42829 if (PyErr_Occurred()) SWIG_fail;
42830 }
42831 {
42832 wxGBPosition * resultptr;
42833 resultptr = new wxGBPosition((wxGBPosition &)(result));
42834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42835 }
42836 return resultobj;
42837 fail:
42838 return NULL;
42839 }
42840
42841
42842 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42843 PyObject *resultobj;
42844 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42845 wxGridBagSizer *result;
42846 PyObject * obj0 = 0 ;
42847 char *kwnames[] = {
42848 (char *) "self", NULL
42849 };
42850
42851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42853 if (SWIG_arg_fail(1)) SWIG_fail;
42854 {
42855 PyThreadState* __tstate = wxPyBeginAllowThreads();
42856 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42857
42858 wxPyEndAllowThreads(__tstate);
42859 if (PyErr_Occurred()) SWIG_fail;
42860 }
42861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42862 return resultobj;
42863 fail:
42864 return NULL;
42865 }
42866
42867
42868 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42869 PyObject *resultobj;
42870 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42871 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42872 PyObject * obj0 = 0 ;
42873 PyObject * obj1 = 0 ;
42874 char *kwnames[] = {
42875 (char *) "self",(char *) "sizer", NULL
42876 };
42877
42878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42880 if (SWIG_arg_fail(1)) SWIG_fail;
42881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42882 if (SWIG_arg_fail(2)) SWIG_fail;
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->SetGBSizer(arg2);
42886
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 Py_INCREF(Py_None); resultobj = Py_None;
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42898 PyObject *obj;
42899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42900 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42901 Py_INCREF(obj);
42902 return Py_BuildValue((char *)"");
42903 }
42904 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42905 PyObject *resultobj;
42906 int arg1 = (int) 0 ;
42907 int arg2 = (int) 0 ;
42908 wxGridBagSizer *result;
42909 PyObject * obj0 = 0 ;
42910 PyObject * obj1 = 0 ;
42911 char *kwnames[] = {
42912 (char *) "vgap",(char *) "hgap", NULL
42913 };
42914
42915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42916 if (obj0) {
42917 {
42918 arg1 = (int)(SWIG_As_int(obj0));
42919 if (SWIG_arg_fail(1)) SWIG_fail;
42920 }
42921 }
42922 if (obj1) {
42923 {
42924 arg2 = (int)(SWIG_As_int(obj1));
42925 if (SWIG_arg_fail(2)) SWIG_fail;
42926 }
42927 }
42928 {
42929 PyThreadState* __tstate = wxPyBeginAllowThreads();
42930 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42931
42932 wxPyEndAllowThreads(__tstate);
42933 if (PyErr_Occurred()) SWIG_fail;
42934 }
42935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42936 return resultobj;
42937 fail:
42938 return NULL;
42939 }
42940
42941
42942 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42943 PyObject *resultobj;
42944 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42945 PyObject *arg2 = (PyObject *) 0 ;
42946 wxGBPosition *arg3 = 0 ;
42947 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42948 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42949 int arg5 = (int) 0 ;
42950 int arg6 = (int) 0 ;
42951 PyObject *arg7 = (PyObject *) NULL ;
42952 wxGBSizerItem *result;
42953 wxGBPosition temp3 ;
42954 wxGBSpan temp4 ;
42955 PyObject * obj0 = 0 ;
42956 PyObject * obj1 = 0 ;
42957 PyObject * obj2 = 0 ;
42958 PyObject * obj3 = 0 ;
42959 PyObject * obj4 = 0 ;
42960 PyObject * obj5 = 0 ;
42961 PyObject * obj6 = 0 ;
42962 char *kwnames[] = {
42963 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42964 };
42965
42966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42968 if (SWIG_arg_fail(1)) SWIG_fail;
42969 arg2 = obj1;
42970 {
42971 arg3 = &temp3;
42972 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42973 }
42974 if (obj3) {
42975 {
42976 arg4 = &temp4;
42977 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42978 }
42979 }
42980 if (obj4) {
42981 {
42982 arg5 = (int)(SWIG_As_int(obj4));
42983 if (SWIG_arg_fail(5)) SWIG_fail;
42984 }
42985 }
42986 if (obj5) {
42987 {
42988 arg6 = (int)(SWIG_As_int(obj5));
42989 if (SWIG_arg_fail(6)) SWIG_fail;
42990 }
42991 }
42992 if (obj6) {
42993 arg7 = obj6;
42994 }
42995 {
42996 PyThreadState* __tstate = wxPyBeginAllowThreads();
42997 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42998
42999 wxPyEndAllowThreads(__tstate);
43000 if (PyErr_Occurred()) SWIG_fail;
43001 }
43002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43003 return resultobj;
43004 fail:
43005 return NULL;
43006 }
43007
43008
43009 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43010 PyObject *resultobj;
43011 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43012 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43013 wxGBSizerItem *result;
43014 PyObject * obj0 = 0 ;
43015 PyObject * obj1 = 0 ;
43016 char *kwnames[] = {
43017 (char *) "self",(char *) "item", NULL
43018 };
43019
43020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43022 if (SWIG_arg_fail(1)) SWIG_fail;
43023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43024 if (SWIG_arg_fail(2)) SWIG_fail;
43025 {
43026 PyThreadState* __tstate = wxPyBeginAllowThreads();
43027 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43028
43029 wxPyEndAllowThreads(__tstate);
43030 if (PyErr_Occurred()) SWIG_fail;
43031 }
43032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43033 return resultobj;
43034 fail:
43035 return NULL;
43036 }
43037
43038
43039 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43040 PyObject *resultobj;
43041 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43042 int arg2 ;
43043 int arg3 ;
43044 wxSize result;
43045 PyObject * obj0 = 0 ;
43046 PyObject * obj1 = 0 ;
43047 PyObject * obj2 = 0 ;
43048 char *kwnames[] = {
43049 (char *) "self",(char *) "row",(char *) "col", NULL
43050 };
43051
43052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) 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 {
43056 arg2 = (int)(SWIG_As_int(obj1));
43057 if (SWIG_arg_fail(2)) SWIG_fail;
43058 }
43059 {
43060 arg3 = (int)(SWIG_As_int(obj2));
43061 if (SWIG_arg_fail(3)) SWIG_fail;
43062 }
43063 {
43064 PyThreadState* __tstate = wxPyBeginAllowThreads();
43065 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43066
43067 wxPyEndAllowThreads(__tstate);
43068 if (PyErr_Occurred()) SWIG_fail;
43069 }
43070 {
43071 wxSize * resultptr;
43072 resultptr = new wxSize((wxSize &)(result));
43073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43074 }
43075 return resultobj;
43076 fail:
43077 return NULL;
43078 }
43079
43080
43081 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43082 PyObject *resultobj;
43083 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43084 wxSize result;
43085 PyObject * obj0 = 0 ;
43086 char *kwnames[] = {
43087 (char *) "self", NULL
43088 };
43089
43090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43092 if (SWIG_arg_fail(1)) SWIG_fail;
43093 {
43094 PyThreadState* __tstate = wxPyBeginAllowThreads();
43095 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43096
43097 wxPyEndAllowThreads(__tstate);
43098 if (PyErr_Occurred()) SWIG_fail;
43099 }
43100 {
43101 wxSize * resultptr;
43102 resultptr = new wxSize((wxSize &)(result));
43103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43104 }
43105 return resultobj;
43106 fail:
43107 return NULL;
43108 }
43109
43110
43111 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43112 PyObject *resultobj;
43113 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43114 wxSize *arg2 = 0 ;
43115 wxSize temp2 ;
43116 PyObject * obj0 = 0 ;
43117 PyObject * obj1 = 0 ;
43118 char *kwnames[] = {
43119 (char *) "self",(char *) "sz", NULL
43120 };
43121
43122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
43127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43128 }
43129 {
43130 PyThreadState* __tstate = wxPyBeginAllowThreads();
43131 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43132
43133 wxPyEndAllowThreads(__tstate);
43134 if (PyErr_Occurred()) SWIG_fail;
43135 }
43136 Py_INCREF(Py_None); resultobj = Py_None;
43137 return resultobj;
43138 fail:
43139 return NULL;
43140 }
43141
43142
43143 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43144 PyObject *resultobj;
43145 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43146 wxWindow *arg2 = (wxWindow *) 0 ;
43147 wxGBPosition result;
43148 PyObject * obj0 = 0 ;
43149 PyObject * obj1 = 0 ;
43150
43151 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43153 if (SWIG_arg_fail(1)) SWIG_fail;
43154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43155 if (SWIG_arg_fail(2)) SWIG_fail;
43156 {
43157 PyThreadState* __tstate = wxPyBeginAllowThreads();
43158 result = (arg1)->GetItemPosition(arg2);
43159
43160 wxPyEndAllowThreads(__tstate);
43161 if (PyErr_Occurred()) SWIG_fail;
43162 }
43163 {
43164 wxGBPosition * resultptr;
43165 resultptr = new wxGBPosition((wxGBPosition &)(result));
43166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43167 }
43168 return resultobj;
43169 fail:
43170 return NULL;
43171 }
43172
43173
43174 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43175 PyObject *resultobj;
43176 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43177 wxSizer *arg2 = (wxSizer *) 0 ;
43178 wxGBPosition result;
43179 PyObject * obj0 = 0 ;
43180 PyObject * obj1 = 0 ;
43181
43182 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43184 if (SWIG_arg_fail(1)) SWIG_fail;
43185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43186 if (SWIG_arg_fail(2)) SWIG_fail;
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 result = (arg1)->GetItemPosition(arg2);
43190
43191 wxPyEndAllowThreads(__tstate);
43192 if (PyErr_Occurred()) SWIG_fail;
43193 }
43194 {
43195 wxGBPosition * resultptr;
43196 resultptr = new wxGBPosition((wxGBPosition &)(result));
43197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43198 }
43199 return resultobj;
43200 fail:
43201 return NULL;
43202 }
43203
43204
43205 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43206 PyObject *resultobj;
43207 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43208 size_t arg2 ;
43209 wxGBPosition result;
43210 PyObject * obj0 = 0 ;
43211 PyObject * obj1 = 0 ;
43212
43213 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43215 if (SWIG_arg_fail(1)) SWIG_fail;
43216 {
43217 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43218 if (SWIG_arg_fail(2)) SWIG_fail;
43219 }
43220 {
43221 PyThreadState* __tstate = wxPyBeginAllowThreads();
43222 result = (arg1)->GetItemPosition(arg2);
43223
43224 wxPyEndAllowThreads(__tstate);
43225 if (PyErr_Occurred()) SWIG_fail;
43226 }
43227 {
43228 wxGBPosition * resultptr;
43229 resultptr = new wxGBPosition((wxGBPosition &)(result));
43230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43231 }
43232 return resultobj;
43233 fail:
43234 return NULL;
43235 }
43236
43237
43238 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43239 int argc;
43240 PyObject *argv[3];
43241 int ii;
43242
43243 argc = PyObject_Length(args);
43244 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43245 argv[ii] = PyTuple_GetItem(args,ii);
43246 }
43247 if (argc == 2) {
43248 int _v;
43249 {
43250 void *ptr;
43251 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43252 _v = 0;
43253 PyErr_Clear();
43254 } else {
43255 _v = 1;
43256 }
43257 }
43258 if (_v) {
43259 {
43260 void *ptr;
43261 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43262 _v = 0;
43263 PyErr_Clear();
43264 } else {
43265 _v = 1;
43266 }
43267 }
43268 if (_v) {
43269 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43270 }
43271 }
43272 }
43273 if (argc == 2) {
43274 int _v;
43275 {
43276 void *ptr;
43277 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43278 _v = 0;
43279 PyErr_Clear();
43280 } else {
43281 _v = 1;
43282 }
43283 }
43284 if (_v) {
43285 {
43286 void *ptr;
43287 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43288 _v = 0;
43289 PyErr_Clear();
43290 } else {
43291 _v = 1;
43292 }
43293 }
43294 if (_v) {
43295 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43296 }
43297 }
43298 }
43299 if (argc == 2) {
43300 int _v;
43301 {
43302 void *ptr;
43303 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43304 _v = 0;
43305 PyErr_Clear();
43306 } else {
43307 _v = 1;
43308 }
43309 }
43310 if (_v) {
43311 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43312 if (_v) {
43313 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43314 }
43315 }
43316 }
43317
43318 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43319 return NULL;
43320 }
43321
43322
43323 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43324 PyObject *resultobj;
43325 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43326 wxWindow *arg2 = (wxWindow *) 0 ;
43327 wxGBPosition *arg3 = 0 ;
43328 bool result;
43329 wxGBPosition temp3 ;
43330 PyObject * obj0 = 0 ;
43331 PyObject * obj1 = 0 ;
43332 PyObject * obj2 = 0 ;
43333
43334 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43336 if (SWIG_arg_fail(1)) SWIG_fail;
43337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43338 if (SWIG_arg_fail(2)) SWIG_fail;
43339 {
43340 arg3 = &temp3;
43341 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43342 }
43343 {
43344 PyThreadState* __tstate = wxPyBeginAllowThreads();
43345 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43346
43347 wxPyEndAllowThreads(__tstate);
43348 if (PyErr_Occurred()) SWIG_fail;
43349 }
43350 {
43351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43352 }
43353 return resultobj;
43354 fail:
43355 return NULL;
43356 }
43357
43358
43359 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43360 PyObject *resultobj;
43361 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43362 wxSizer *arg2 = (wxSizer *) 0 ;
43363 wxGBPosition *arg3 = 0 ;
43364 bool result;
43365 wxGBPosition temp3 ;
43366 PyObject * obj0 = 0 ;
43367 PyObject * obj1 = 0 ;
43368 PyObject * obj2 = 0 ;
43369
43370 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43372 if (SWIG_arg_fail(1)) SWIG_fail;
43373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43374 if (SWIG_arg_fail(2)) SWIG_fail;
43375 {
43376 arg3 = &temp3;
43377 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43378 }
43379 {
43380 PyThreadState* __tstate = wxPyBeginAllowThreads();
43381 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43382
43383 wxPyEndAllowThreads(__tstate);
43384 if (PyErr_Occurred()) SWIG_fail;
43385 }
43386 {
43387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43388 }
43389 return resultobj;
43390 fail:
43391 return NULL;
43392 }
43393
43394
43395 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43396 PyObject *resultobj;
43397 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43398 size_t arg2 ;
43399 wxGBPosition *arg3 = 0 ;
43400 bool result;
43401 wxGBPosition temp3 ;
43402 PyObject * obj0 = 0 ;
43403 PyObject * obj1 = 0 ;
43404 PyObject * obj2 = 0 ;
43405
43406 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43408 if (SWIG_arg_fail(1)) SWIG_fail;
43409 {
43410 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43411 if (SWIG_arg_fail(2)) SWIG_fail;
43412 }
43413 {
43414 arg3 = &temp3;
43415 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43416 }
43417 {
43418 PyThreadState* __tstate = wxPyBeginAllowThreads();
43419 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43420
43421 wxPyEndAllowThreads(__tstate);
43422 if (PyErr_Occurred()) SWIG_fail;
43423 }
43424 {
43425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43426 }
43427 return resultobj;
43428 fail:
43429 return NULL;
43430 }
43431
43432
43433 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43434 int argc;
43435 PyObject *argv[4];
43436 int ii;
43437
43438 argc = PyObject_Length(args);
43439 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43440 argv[ii] = PyTuple_GetItem(args,ii);
43441 }
43442 if (argc == 3) {
43443 int _v;
43444 {
43445 void *ptr;
43446 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43447 _v = 0;
43448 PyErr_Clear();
43449 } else {
43450 _v = 1;
43451 }
43452 }
43453 if (_v) {
43454 {
43455 void *ptr;
43456 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43457 _v = 0;
43458 PyErr_Clear();
43459 } else {
43460 _v = 1;
43461 }
43462 }
43463 if (_v) {
43464 {
43465 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43466 }
43467 if (_v) {
43468 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43469 }
43470 }
43471 }
43472 }
43473 if (argc == 3) {
43474 int _v;
43475 {
43476 void *ptr;
43477 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43478 _v = 0;
43479 PyErr_Clear();
43480 } else {
43481 _v = 1;
43482 }
43483 }
43484 if (_v) {
43485 {
43486 void *ptr;
43487 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43488 _v = 0;
43489 PyErr_Clear();
43490 } else {
43491 _v = 1;
43492 }
43493 }
43494 if (_v) {
43495 {
43496 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43497 }
43498 if (_v) {
43499 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43500 }
43501 }
43502 }
43503 }
43504 if (argc == 3) {
43505 int _v;
43506 {
43507 void *ptr;
43508 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43509 _v = 0;
43510 PyErr_Clear();
43511 } else {
43512 _v = 1;
43513 }
43514 }
43515 if (_v) {
43516 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43517 if (_v) {
43518 {
43519 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43520 }
43521 if (_v) {
43522 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43523 }
43524 }
43525 }
43526 }
43527
43528 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43529 return NULL;
43530 }
43531
43532
43533 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43534 PyObject *resultobj;
43535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43536 wxWindow *arg2 = (wxWindow *) 0 ;
43537 wxGBSpan result;
43538 PyObject * obj0 = 0 ;
43539 PyObject * obj1 = 0 ;
43540
43541 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43543 if (SWIG_arg_fail(1)) SWIG_fail;
43544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43545 if (SWIG_arg_fail(2)) SWIG_fail;
43546 {
43547 PyThreadState* __tstate = wxPyBeginAllowThreads();
43548 result = (arg1)->GetItemSpan(arg2);
43549
43550 wxPyEndAllowThreads(__tstate);
43551 if (PyErr_Occurred()) SWIG_fail;
43552 }
43553 {
43554 wxGBSpan * resultptr;
43555 resultptr = new wxGBSpan((wxGBSpan &)(result));
43556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43557 }
43558 return resultobj;
43559 fail:
43560 return NULL;
43561 }
43562
43563
43564 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43565 PyObject *resultobj;
43566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43567 wxSizer *arg2 = (wxSizer *) 0 ;
43568 wxGBSpan result;
43569 PyObject * obj0 = 0 ;
43570 PyObject * obj1 = 0 ;
43571
43572 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43574 if (SWIG_arg_fail(1)) SWIG_fail;
43575 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43576 if (SWIG_arg_fail(2)) SWIG_fail;
43577 {
43578 PyThreadState* __tstate = wxPyBeginAllowThreads();
43579 result = (arg1)->GetItemSpan(arg2);
43580
43581 wxPyEndAllowThreads(__tstate);
43582 if (PyErr_Occurred()) SWIG_fail;
43583 }
43584 {
43585 wxGBSpan * resultptr;
43586 resultptr = new wxGBSpan((wxGBSpan &)(result));
43587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43588 }
43589 return resultobj;
43590 fail:
43591 return NULL;
43592 }
43593
43594
43595 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43596 PyObject *resultobj;
43597 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43598 size_t arg2 ;
43599 wxGBSpan result;
43600 PyObject * obj0 = 0 ;
43601 PyObject * obj1 = 0 ;
43602
43603 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43605 if (SWIG_arg_fail(1)) SWIG_fail;
43606 {
43607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43608 if (SWIG_arg_fail(2)) SWIG_fail;
43609 }
43610 {
43611 PyThreadState* __tstate = wxPyBeginAllowThreads();
43612 result = (arg1)->GetItemSpan(arg2);
43613
43614 wxPyEndAllowThreads(__tstate);
43615 if (PyErr_Occurred()) SWIG_fail;
43616 }
43617 {
43618 wxGBSpan * resultptr;
43619 resultptr = new wxGBSpan((wxGBSpan &)(result));
43620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43621 }
43622 return resultobj;
43623 fail:
43624 return NULL;
43625 }
43626
43627
43628 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43629 int argc;
43630 PyObject *argv[3];
43631 int ii;
43632
43633 argc = PyObject_Length(args);
43634 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43635 argv[ii] = PyTuple_GetItem(args,ii);
43636 }
43637 if (argc == 2) {
43638 int _v;
43639 {
43640 void *ptr;
43641 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43642 _v = 0;
43643 PyErr_Clear();
43644 } else {
43645 _v = 1;
43646 }
43647 }
43648 if (_v) {
43649 {
43650 void *ptr;
43651 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43652 _v = 0;
43653 PyErr_Clear();
43654 } else {
43655 _v = 1;
43656 }
43657 }
43658 if (_v) {
43659 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43660 }
43661 }
43662 }
43663 if (argc == 2) {
43664 int _v;
43665 {
43666 void *ptr;
43667 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43668 _v = 0;
43669 PyErr_Clear();
43670 } else {
43671 _v = 1;
43672 }
43673 }
43674 if (_v) {
43675 {
43676 void *ptr;
43677 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43678 _v = 0;
43679 PyErr_Clear();
43680 } else {
43681 _v = 1;
43682 }
43683 }
43684 if (_v) {
43685 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43686 }
43687 }
43688 }
43689 if (argc == 2) {
43690 int _v;
43691 {
43692 void *ptr;
43693 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43694 _v = 0;
43695 PyErr_Clear();
43696 } else {
43697 _v = 1;
43698 }
43699 }
43700 if (_v) {
43701 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43702 if (_v) {
43703 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43704 }
43705 }
43706 }
43707
43708 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43709 return NULL;
43710 }
43711
43712
43713 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43714 PyObject *resultobj;
43715 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43716 wxWindow *arg2 = (wxWindow *) 0 ;
43717 wxGBSpan *arg3 = 0 ;
43718 bool result;
43719 wxGBSpan temp3 ;
43720 PyObject * obj0 = 0 ;
43721 PyObject * obj1 = 0 ;
43722 PyObject * obj2 = 0 ;
43723
43724 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43726 if (SWIG_arg_fail(1)) SWIG_fail;
43727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43728 if (SWIG_arg_fail(2)) SWIG_fail;
43729 {
43730 arg3 = &temp3;
43731 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43732 }
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43736
43737 wxPyEndAllowThreads(__tstate);
43738 if (PyErr_Occurred()) SWIG_fail;
43739 }
43740 {
43741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43742 }
43743 return resultobj;
43744 fail:
43745 return NULL;
43746 }
43747
43748
43749 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43750 PyObject *resultobj;
43751 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43752 wxSizer *arg2 = (wxSizer *) 0 ;
43753 wxGBSpan *arg3 = 0 ;
43754 bool result;
43755 wxGBSpan temp3 ;
43756 PyObject * obj0 = 0 ;
43757 PyObject * obj1 = 0 ;
43758 PyObject * obj2 = 0 ;
43759
43760 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43762 if (SWIG_arg_fail(1)) SWIG_fail;
43763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43764 if (SWIG_arg_fail(2)) SWIG_fail;
43765 {
43766 arg3 = &temp3;
43767 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43768 }
43769 {
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43772
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 {
43777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43778 }
43779 return resultobj;
43780 fail:
43781 return NULL;
43782 }
43783
43784
43785 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43786 PyObject *resultobj;
43787 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43788 size_t arg2 ;
43789 wxGBSpan *arg3 = 0 ;
43790 bool result;
43791 wxGBSpan temp3 ;
43792 PyObject * obj0 = 0 ;
43793 PyObject * obj1 = 0 ;
43794 PyObject * obj2 = 0 ;
43795
43796 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43798 if (SWIG_arg_fail(1)) SWIG_fail;
43799 {
43800 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43801 if (SWIG_arg_fail(2)) SWIG_fail;
43802 }
43803 {
43804 arg3 = &temp3;
43805 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43806 }
43807 {
43808 PyThreadState* __tstate = wxPyBeginAllowThreads();
43809 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43810
43811 wxPyEndAllowThreads(__tstate);
43812 if (PyErr_Occurred()) SWIG_fail;
43813 }
43814 {
43815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43816 }
43817 return resultobj;
43818 fail:
43819 return NULL;
43820 }
43821
43822
43823 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43824 int argc;
43825 PyObject *argv[4];
43826 int ii;
43827
43828 argc = PyObject_Length(args);
43829 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43830 argv[ii] = PyTuple_GetItem(args,ii);
43831 }
43832 if (argc == 3) {
43833 int _v;
43834 {
43835 void *ptr;
43836 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43837 _v = 0;
43838 PyErr_Clear();
43839 } else {
43840 _v = 1;
43841 }
43842 }
43843 if (_v) {
43844 {
43845 void *ptr;
43846 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43847 _v = 0;
43848 PyErr_Clear();
43849 } else {
43850 _v = 1;
43851 }
43852 }
43853 if (_v) {
43854 {
43855 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43856 }
43857 if (_v) {
43858 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43859 }
43860 }
43861 }
43862 }
43863 if (argc == 3) {
43864 int _v;
43865 {
43866 void *ptr;
43867 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43868 _v = 0;
43869 PyErr_Clear();
43870 } else {
43871 _v = 1;
43872 }
43873 }
43874 if (_v) {
43875 {
43876 void *ptr;
43877 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43878 _v = 0;
43879 PyErr_Clear();
43880 } else {
43881 _v = 1;
43882 }
43883 }
43884 if (_v) {
43885 {
43886 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43887 }
43888 if (_v) {
43889 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43890 }
43891 }
43892 }
43893 }
43894 if (argc == 3) {
43895 int _v;
43896 {
43897 void *ptr;
43898 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43899 _v = 0;
43900 PyErr_Clear();
43901 } else {
43902 _v = 1;
43903 }
43904 }
43905 if (_v) {
43906 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43907 if (_v) {
43908 {
43909 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43910 }
43911 if (_v) {
43912 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43913 }
43914 }
43915 }
43916 }
43917
43918 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43919 return NULL;
43920 }
43921
43922
43923 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43924 PyObject *resultobj;
43925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43926 wxWindow *arg2 = (wxWindow *) 0 ;
43927 wxGBSizerItem *result;
43928 PyObject * obj0 = 0 ;
43929 PyObject * obj1 = 0 ;
43930
43931 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43933 if (SWIG_arg_fail(1)) SWIG_fail;
43934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43935 if (SWIG_arg_fail(2)) SWIG_fail;
43936 {
43937 PyThreadState* __tstate = wxPyBeginAllowThreads();
43938 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43939
43940 wxPyEndAllowThreads(__tstate);
43941 if (PyErr_Occurred()) SWIG_fail;
43942 }
43943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43944 return resultobj;
43945 fail:
43946 return NULL;
43947 }
43948
43949
43950 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43951 PyObject *resultobj;
43952 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43953 wxSizer *arg2 = (wxSizer *) 0 ;
43954 wxGBSizerItem *result;
43955 PyObject * obj0 = 0 ;
43956 PyObject * obj1 = 0 ;
43957
43958 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43960 if (SWIG_arg_fail(1)) SWIG_fail;
43961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43962 if (SWIG_arg_fail(2)) SWIG_fail;
43963 {
43964 PyThreadState* __tstate = wxPyBeginAllowThreads();
43965 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43966
43967 wxPyEndAllowThreads(__tstate);
43968 if (PyErr_Occurred()) SWIG_fail;
43969 }
43970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43971 return resultobj;
43972 fail:
43973 return NULL;
43974 }
43975
43976
43977 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43978 int argc;
43979 PyObject *argv[3];
43980 int ii;
43981
43982 argc = PyObject_Length(args);
43983 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43984 argv[ii] = PyTuple_GetItem(args,ii);
43985 }
43986 if (argc == 2) {
43987 int _v;
43988 {
43989 void *ptr;
43990 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43991 _v = 0;
43992 PyErr_Clear();
43993 } else {
43994 _v = 1;
43995 }
43996 }
43997 if (_v) {
43998 {
43999 void *ptr;
44000 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44001 _v = 0;
44002 PyErr_Clear();
44003 } else {
44004 _v = 1;
44005 }
44006 }
44007 if (_v) {
44008 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44009 }
44010 }
44011 }
44012 if (argc == 2) {
44013 int _v;
44014 {
44015 void *ptr;
44016 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44017 _v = 0;
44018 PyErr_Clear();
44019 } else {
44020 _v = 1;
44021 }
44022 }
44023 if (_v) {
44024 {
44025 void *ptr;
44026 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44027 _v = 0;
44028 PyErr_Clear();
44029 } else {
44030 _v = 1;
44031 }
44032 }
44033 if (_v) {
44034 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44035 }
44036 }
44037 }
44038
44039 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44040 return NULL;
44041 }
44042
44043
44044 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44045 PyObject *resultobj;
44046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44047 wxGBPosition *arg2 = 0 ;
44048 wxGBSizerItem *result;
44049 wxGBPosition temp2 ;
44050 PyObject * obj0 = 0 ;
44051 PyObject * obj1 = 0 ;
44052 char *kwnames[] = {
44053 (char *) "self",(char *) "pos", NULL
44054 };
44055
44056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44058 if (SWIG_arg_fail(1)) SWIG_fail;
44059 {
44060 arg2 = &temp2;
44061 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44062 }
44063 {
44064 PyThreadState* __tstate = wxPyBeginAllowThreads();
44065 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44066
44067 wxPyEndAllowThreads(__tstate);
44068 if (PyErr_Occurred()) SWIG_fail;
44069 }
44070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj;
44079 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44080 wxPoint *arg2 = 0 ;
44081 wxGBSizerItem *result;
44082 wxPoint temp2 ;
44083 PyObject * obj0 = 0 ;
44084 PyObject * obj1 = 0 ;
44085 char *kwnames[] = {
44086 (char *) "self",(char *) "pt", NULL
44087 };
44088
44089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44091 if (SWIG_arg_fail(1)) SWIG_fail;
44092 {
44093 arg2 = &temp2;
44094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44095 }
44096 {
44097 PyThreadState* __tstate = wxPyBeginAllowThreads();
44098 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44099
44100 wxPyEndAllowThreads(__tstate);
44101 if (PyErr_Occurred()) SWIG_fail;
44102 }
44103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44104 return resultobj;
44105 fail:
44106 return NULL;
44107 }
44108
44109
44110 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44111 PyObject *resultobj;
44112 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44113 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44114 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44115 bool result;
44116 PyObject * obj0 = 0 ;
44117 PyObject * obj1 = 0 ;
44118 PyObject * obj2 = 0 ;
44119 char *kwnames[] = {
44120 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44121 };
44122
44123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44125 if (SWIG_arg_fail(1)) SWIG_fail;
44126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44127 if (SWIG_arg_fail(2)) SWIG_fail;
44128 if (obj2) {
44129 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44130 if (SWIG_arg_fail(3)) SWIG_fail;
44131 }
44132 {
44133 PyThreadState* __tstate = wxPyBeginAllowThreads();
44134 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44135
44136 wxPyEndAllowThreads(__tstate);
44137 if (PyErr_Occurred()) SWIG_fail;
44138 }
44139 {
44140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44141 }
44142 return resultobj;
44143 fail:
44144 return NULL;
44145 }
44146
44147
44148 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44149 PyObject *resultobj;
44150 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44151 wxGBPosition *arg2 = 0 ;
44152 wxGBSpan *arg3 = 0 ;
44153 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44154 bool result;
44155 wxGBPosition temp2 ;
44156 wxGBSpan temp3 ;
44157 PyObject * obj0 = 0 ;
44158 PyObject * obj1 = 0 ;
44159 PyObject * obj2 = 0 ;
44160 PyObject * obj3 = 0 ;
44161 char *kwnames[] = {
44162 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44163 };
44164
44165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44167 if (SWIG_arg_fail(1)) SWIG_fail;
44168 {
44169 arg2 = &temp2;
44170 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44171 }
44172 {
44173 arg3 = &temp3;
44174 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44175 }
44176 if (obj3) {
44177 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44178 if (SWIG_arg_fail(4)) SWIG_fail;
44179 }
44180 {
44181 PyThreadState* __tstate = wxPyBeginAllowThreads();
44182 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44183
44184 wxPyEndAllowThreads(__tstate);
44185 if (PyErr_Occurred()) SWIG_fail;
44186 }
44187 {
44188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44189 }
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44197 PyObject *obj;
44198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44199 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44200 Py_INCREF(obj);
44201 return Py_BuildValue((char *)"");
44202 }
44203 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44204 PyObject *resultobj;
44205 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44206 wxRelationship arg2 ;
44207 wxWindow *arg3 = (wxWindow *) 0 ;
44208 wxEdge arg4 ;
44209 int arg5 = (int) 0 ;
44210 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44211 PyObject * obj0 = 0 ;
44212 PyObject * obj1 = 0 ;
44213 PyObject * obj2 = 0 ;
44214 PyObject * obj3 = 0 ;
44215 PyObject * obj4 = 0 ;
44216 PyObject * obj5 = 0 ;
44217 char *kwnames[] = {
44218 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44219 };
44220
44221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44223 if (SWIG_arg_fail(1)) SWIG_fail;
44224 {
44225 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44226 if (SWIG_arg_fail(2)) SWIG_fail;
44227 }
44228 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44229 if (SWIG_arg_fail(3)) SWIG_fail;
44230 {
44231 arg4 = (wxEdge)(SWIG_As_int(obj3));
44232 if (SWIG_arg_fail(4)) SWIG_fail;
44233 }
44234 if (obj4) {
44235 {
44236 arg5 = (int)(SWIG_As_int(obj4));
44237 if (SWIG_arg_fail(5)) SWIG_fail;
44238 }
44239 }
44240 if (obj5) {
44241 {
44242 arg6 = (int)(SWIG_As_int(obj5));
44243 if (SWIG_arg_fail(6)) SWIG_fail;
44244 }
44245 }
44246 {
44247 PyThreadState* __tstate = wxPyBeginAllowThreads();
44248 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44249
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 Py_INCREF(Py_None); resultobj = Py_None;
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44261 PyObject *resultobj;
44262 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44263 wxWindow *arg2 = (wxWindow *) 0 ;
44264 int arg3 = (int) 0 ;
44265 PyObject * obj0 = 0 ;
44266 PyObject * obj1 = 0 ;
44267 PyObject * obj2 = 0 ;
44268 char *kwnames[] = {
44269 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44270 };
44271
44272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44274 if (SWIG_arg_fail(1)) SWIG_fail;
44275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44276 if (SWIG_arg_fail(2)) SWIG_fail;
44277 if (obj2) {
44278 {
44279 arg3 = (int)(SWIG_As_int(obj2));
44280 if (SWIG_arg_fail(3)) SWIG_fail;
44281 }
44282 }
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 (arg1)->LeftOf(arg2,arg3);
44286
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 Py_INCREF(Py_None); resultobj = Py_None;
44291 return resultobj;
44292 fail:
44293 return NULL;
44294 }
44295
44296
44297 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44298 PyObject *resultobj;
44299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44300 wxWindow *arg2 = (wxWindow *) 0 ;
44301 int arg3 = (int) 0 ;
44302 PyObject * obj0 = 0 ;
44303 PyObject * obj1 = 0 ;
44304 PyObject * obj2 = 0 ;
44305 char *kwnames[] = {
44306 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44307 };
44308
44309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44311 if (SWIG_arg_fail(1)) SWIG_fail;
44312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44313 if (SWIG_arg_fail(2)) SWIG_fail;
44314 if (obj2) {
44315 {
44316 arg3 = (int)(SWIG_As_int(obj2));
44317 if (SWIG_arg_fail(3)) SWIG_fail;
44318 }
44319 }
44320 {
44321 PyThreadState* __tstate = wxPyBeginAllowThreads();
44322 (arg1)->RightOf(arg2,arg3);
44323
44324 wxPyEndAllowThreads(__tstate);
44325 if (PyErr_Occurred()) SWIG_fail;
44326 }
44327 Py_INCREF(Py_None); resultobj = Py_None;
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44335 PyObject *resultobj;
44336 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44337 wxWindow *arg2 = (wxWindow *) 0 ;
44338 int arg3 = (int) 0 ;
44339 PyObject * obj0 = 0 ;
44340 PyObject * obj1 = 0 ;
44341 PyObject * obj2 = 0 ;
44342 char *kwnames[] = {
44343 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44344 };
44345
44346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44348 if (SWIG_arg_fail(1)) SWIG_fail;
44349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44350 if (SWIG_arg_fail(2)) SWIG_fail;
44351 if (obj2) {
44352 {
44353 arg3 = (int)(SWIG_As_int(obj2));
44354 if (SWIG_arg_fail(3)) SWIG_fail;
44355 }
44356 }
44357 {
44358 PyThreadState* __tstate = wxPyBeginAllowThreads();
44359 (arg1)->Above(arg2,arg3);
44360
44361 wxPyEndAllowThreads(__tstate);
44362 if (PyErr_Occurred()) SWIG_fail;
44363 }
44364 Py_INCREF(Py_None); resultobj = Py_None;
44365 return resultobj;
44366 fail:
44367 return NULL;
44368 }
44369
44370
44371 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44372 PyObject *resultobj;
44373 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44374 wxWindow *arg2 = (wxWindow *) 0 ;
44375 int arg3 = (int) 0 ;
44376 PyObject * obj0 = 0 ;
44377 PyObject * obj1 = 0 ;
44378 PyObject * obj2 = 0 ;
44379 char *kwnames[] = {
44380 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44381 };
44382
44383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44385 if (SWIG_arg_fail(1)) SWIG_fail;
44386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44387 if (SWIG_arg_fail(2)) SWIG_fail;
44388 if (obj2) {
44389 {
44390 arg3 = (int)(SWIG_As_int(obj2));
44391 if (SWIG_arg_fail(3)) SWIG_fail;
44392 }
44393 }
44394 {
44395 PyThreadState* __tstate = wxPyBeginAllowThreads();
44396 (arg1)->Below(arg2,arg3);
44397
44398 wxPyEndAllowThreads(__tstate);
44399 if (PyErr_Occurred()) SWIG_fail;
44400 }
44401 Py_INCREF(Py_None); resultobj = Py_None;
44402 return resultobj;
44403 fail:
44404 return NULL;
44405 }
44406
44407
44408 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44409 PyObject *resultobj;
44410 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44411 wxWindow *arg2 = (wxWindow *) 0 ;
44412 wxEdge arg3 ;
44413 int arg4 = (int) 0 ;
44414 PyObject * obj0 = 0 ;
44415 PyObject * obj1 = 0 ;
44416 PyObject * obj2 = 0 ;
44417 PyObject * obj3 = 0 ;
44418 char *kwnames[] = {
44419 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44420 };
44421
44422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44424 if (SWIG_arg_fail(1)) SWIG_fail;
44425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44426 if (SWIG_arg_fail(2)) SWIG_fail;
44427 {
44428 arg3 = (wxEdge)(SWIG_As_int(obj2));
44429 if (SWIG_arg_fail(3)) SWIG_fail;
44430 }
44431 if (obj3) {
44432 {
44433 arg4 = (int)(SWIG_As_int(obj3));
44434 if (SWIG_arg_fail(4)) SWIG_fail;
44435 }
44436 }
44437 {
44438 PyThreadState* __tstate = wxPyBeginAllowThreads();
44439 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44440
44441 wxPyEndAllowThreads(__tstate);
44442 if (PyErr_Occurred()) SWIG_fail;
44443 }
44444 Py_INCREF(Py_None); resultobj = Py_None;
44445 return resultobj;
44446 fail:
44447 return NULL;
44448 }
44449
44450
44451 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44452 PyObject *resultobj;
44453 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44454 wxWindow *arg2 = (wxWindow *) 0 ;
44455 wxEdge arg3 ;
44456 int arg4 ;
44457 PyObject * obj0 = 0 ;
44458 PyObject * obj1 = 0 ;
44459 PyObject * obj2 = 0 ;
44460 PyObject * obj3 = 0 ;
44461 char *kwnames[] = {
44462 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44463 };
44464
44465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44467 if (SWIG_arg_fail(1)) SWIG_fail;
44468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44469 if (SWIG_arg_fail(2)) SWIG_fail;
44470 {
44471 arg3 = (wxEdge)(SWIG_As_int(obj2));
44472 if (SWIG_arg_fail(3)) SWIG_fail;
44473 }
44474 {
44475 arg4 = (int)(SWIG_As_int(obj3));
44476 if (SWIG_arg_fail(4)) SWIG_fail;
44477 }
44478 {
44479 PyThreadState* __tstate = wxPyBeginAllowThreads();
44480 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44481
44482 wxPyEndAllowThreads(__tstate);
44483 if (PyErr_Occurred()) SWIG_fail;
44484 }
44485 Py_INCREF(Py_None); resultobj = Py_None;
44486 return resultobj;
44487 fail:
44488 return NULL;
44489 }
44490
44491
44492 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44493 PyObject *resultobj;
44494 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44495 int arg2 ;
44496 PyObject * obj0 = 0 ;
44497 PyObject * obj1 = 0 ;
44498 char *kwnames[] = {
44499 (char *) "self",(char *) "val", NULL
44500 };
44501
44502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44504 if (SWIG_arg_fail(1)) SWIG_fail;
44505 {
44506 arg2 = (int)(SWIG_As_int(obj1));
44507 if (SWIG_arg_fail(2)) SWIG_fail;
44508 }
44509 {
44510 PyThreadState* __tstate = wxPyBeginAllowThreads();
44511 (arg1)->Absolute(arg2);
44512
44513 wxPyEndAllowThreads(__tstate);
44514 if (PyErr_Occurred()) SWIG_fail;
44515 }
44516 Py_INCREF(Py_None); resultobj = Py_None;
44517 return resultobj;
44518 fail:
44519 return NULL;
44520 }
44521
44522
44523 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44524 PyObject *resultobj;
44525 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44526 PyObject * obj0 = 0 ;
44527 char *kwnames[] = {
44528 (char *) "self", NULL
44529 };
44530
44531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44533 if (SWIG_arg_fail(1)) SWIG_fail;
44534 {
44535 PyThreadState* __tstate = wxPyBeginAllowThreads();
44536 (arg1)->Unconstrained();
44537
44538 wxPyEndAllowThreads(__tstate);
44539 if (PyErr_Occurred()) SWIG_fail;
44540 }
44541 Py_INCREF(Py_None); resultobj = Py_None;
44542 return resultobj;
44543 fail:
44544 return NULL;
44545 }
44546
44547
44548 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44549 PyObject *resultobj;
44550 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44551 PyObject * obj0 = 0 ;
44552 char *kwnames[] = {
44553 (char *) "self", NULL
44554 };
44555
44556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44558 if (SWIG_arg_fail(1)) SWIG_fail;
44559 {
44560 PyThreadState* __tstate = wxPyBeginAllowThreads();
44561 (arg1)->AsIs();
44562
44563 wxPyEndAllowThreads(__tstate);
44564 if (PyErr_Occurred()) SWIG_fail;
44565 }
44566 Py_INCREF(Py_None); resultobj = Py_None;
44567 return resultobj;
44568 fail:
44569 return NULL;
44570 }
44571
44572
44573 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44574 PyObject *resultobj;
44575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44576 wxWindow *result;
44577 PyObject * obj0 = 0 ;
44578 char *kwnames[] = {
44579 (char *) "self", NULL
44580 };
44581
44582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44584 if (SWIG_arg_fail(1)) SWIG_fail;
44585 {
44586 PyThreadState* __tstate = wxPyBeginAllowThreads();
44587 result = (wxWindow *)(arg1)->GetOtherWindow();
44588
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 {
44593 resultobj = wxPyMake_wxObject(result, 0);
44594 }
44595 return resultobj;
44596 fail:
44597 return NULL;
44598 }
44599
44600
44601 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44602 PyObject *resultobj;
44603 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44604 wxEdge result;
44605 PyObject * obj0 = 0 ;
44606 char *kwnames[] = {
44607 (char *) "self", NULL
44608 };
44609
44610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44612 if (SWIG_arg_fail(1)) SWIG_fail;
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44616
44617 wxPyEndAllowThreads(__tstate);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 }
44620 resultobj = SWIG_From_int((result));
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj;
44629 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44630 wxEdge arg2 ;
44631 PyObject * obj0 = 0 ;
44632 PyObject * obj1 = 0 ;
44633 char *kwnames[] = {
44634 (char *) "self",(char *) "which", NULL
44635 };
44636
44637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44639 if (SWIG_arg_fail(1)) SWIG_fail;
44640 {
44641 arg2 = (wxEdge)(SWIG_As_int(obj1));
44642 if (SWIG_arg_fail(2)) SWIG_fail;
44643 }
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 (arg1)->SetEdge((wxEdge )arg2);
44647
44648 wxPyEndAllowThreads(__tstate);
44649 if (PyErr_Occurred()) SWIG_fail;
44650 }
44651 Py_INCREF(Py_None); resultobj = Py_None;
44652 return resultobj;
44653 fail:
44654 return NULL;
44655 }
44656
44657
44658 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44659 PyObject *resultobj;
44660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44661 int arg2 ;
44662 PyObject * obj0 = 0 ;
44663 PyObject * obj1 = 0 ;
44664 char *kwnames[] = {
44665 (char *) "self",(char *) "v", NULL
44666 };
44667
44668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44670 if (SWIG_arg_fail(1)) SWIG_fail;
44671 {
44672 arg2 = (int)(SWIG_As_int(obj1));
44673 if (SWIG_arg_fail(2)) SWIG_fail;
44674 }
44675 {
44676 PyThreadState* __tstate = wxPyBeginAllowThreads();
44677 (arg1)->SetValue(arg2);
44678
44679 wxPyEndAllowThreads(__tstate);
44680 if (PyErr_Occurred()) SWIG_fail;
44681 }
44682 Py_INCREF(Py_None); resultobj = Py_None;
44683 return resultobj;
44684 fail:
44685 return NULL;
44686 }
44687
44688
44689 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44690 PyObject *resultobj;
44691 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44692 int result;
44693 PyObject * obj0 = 0 ;
44694 char *kwnames[] = {
44695 (char *) "self", NULL
44696 };
44697
44698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44700 if (SWIG_arg_fail(1)) SWIG_fail;
44701 {
44702 PyThreadState* __tstate = wxPyBeginAllowThreads();
44703 result = (int)(arg1)->GetMargin();
44704
44705 wxPyEndAllowThreads(__tstate);
44706 if (PyErr_Occurred()) SWIG_fail;
44707 }
44708 {
44709 resultobj = SWIG_From_int((int)(result));
44710 }
44711 return resultobj;
44712 fail:
44713 return NULL;
44714 }
44715
44716
44717 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44718 PyObject *resultobj;
44719 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44720 int arg2 ;
44721 PyObject * obj0 = 0 ;
44722 PyObject * obj1 = 0 ;
44723 char *kwnames[] = {
44724 (char *) "self",(char *) "m", NULL
44725 };
44726
44727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44729 if (SWIG_arg_fail(1)) SWIG_fail;
44730 {
44731 arg2 = (int)(SWIG_As_int(obj1));
44732 if (SWIG_arg_fail(2)) SWIG_fail;
44733 }
44734 {
44735 PyThreadState* __tstate = wxPyBeginAllowThreads();
44736 (arg1)->SetMargin(arg2);
44737
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 Py_INCREF(Py_None); resultobj = Py_None;
44742 return resultobj;
44743 fail:
44744 return NULL;
44745 }
44746
44747
44748 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44749 PyObject *resultobj;
44750 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44751 int result;
44752 PyObject * obj0 = 0 ;
44753 char *kwnames[] = {
44754 (char *) "self", NULL
44755 };
44756
44757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44759 if (SWIG_arg_fail(1)) SWIG_fail;
44760 {
44761 PyThreadState* __tstate = wxPyBeginAllowThreads();
44762 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44763
44764 wxPyEndAllowThreads(__tstate);
44765 if (PyErr_Occurred()) SWIG_fail;
44766 }
44767 {
44768 resultobj = SWIG_From_int((int)(result));
44769 }
44770 return resultobj;
44771 fail:
44772 return NULL;
44773 }
44774
44775
44776 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44777 PyObject *resultobj;
44778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44779 int result;
44780 PyObject * obj0 = 0 ;
44781 char *kwnames[] = {
44782 (char *) "self", NULL
44783 };
44784
44785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44787 if (SWIG_arg_fail(1)) SWIG_fail;
44788 {
44789 PyThreadState* __tstate = wxPyBeginAllowThreads();
44790 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44791
44792 wxPyEndAllowThreads(__tstate);
44793 if (PyErr_Occurred()) SWIG_fail;
44794 }
44795 {
44796 resultobj = SWIG_From_int((int)(result));
44797 }
44798 return resultobj;
44799 fail:
44800 return NULL;
44801 }
44802
44803
44804 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44805 PyObject *resultobj;
44806 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44807 int result;
44808 PyObject * obj0 = 0 ;
44809 char *kwnames[] = {
44810 (char *) "self", NULL
44811 };
44812
44813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44815 if (SWIG_arg_fail(1)) SWIG_fail;
44816 {
44817 PyThreadState* __tstate = wxPyBeginAllowThreads();
44818 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44819
44820 wxPyEndAllowThreads(__tstate);
44821 if (PyErr_Occurred()) SWIG_fail;
44822 }
44823 {
44824 resultobj = SWIG_From_int((int)(result));
44825 }
44826 return resultobj;
44827 fail:
44828 return NULL;
44829 }
44830
44831
44832 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44833 PyObject *resultobj;
44834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44835 bool result;
44836 PyObject * obj0 = 0 ;
44837 char *kwnames[] = {
44838 (char *) "self", NULL
44839 };
44840
44841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44843 if (SWIG_arg_fail(1)) SWIG_fail;
44844 {
44845 PyThreadState* __tstate = wxPyBeginAllowThreads();
44846 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44847
44848 wxPyEndAllowThreads(__tstate);
44849 if (PyErr_Occurred()) SWIG_fail;
44850 }
44851 {
44852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44853 }
44854 return resultobj;
44855 fail:
44856 return NULL;
44857 }
44858
44859
44860 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44861 PyObject *resultobj;
44862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44863 bool arg2 ;
44864 PyObject * obj0 = 0 ;
44865 PyObject * obj1 = 0 ;
44866 char *kwnames[] = {
44867 (char *) "self",(char *) "d", NULL
44868 };
44869
44870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44872 if (SWIG_arg_fail(1)) SWIG_fail;
44873 {
44874 arg2 = (bool)(SWIG_As_bool(obj1));
44875 if (SWIG_arg_fail(2)) SWIG_fail;
44876 }
44877 {
44878 PyThreadState* __tstate = wxPyBeginAllowThreads();
44879 (arg1)->SetDone(arg2);
44880
44881 wxPyEndAllowThreads(__tstate);
44882 if (PyErr_Occurred()) SWIG_fail;
44883 }
44884 Py_INCREF(Py_None); resultobj = Py_None;
44885 return resultobj;
44886 fail:
44887 return NULL;
44888 }
44889
44890
44891 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj;
44893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44894 wxRelationship result;
44895 PyObject * obj0 = 0 ;
44896 char *kwnames[] = {
44897 (char *) "self", NULL
44898 };
44899
44900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44902 if (SWIG_arg_fail(1)) SWIG_fail;
44903 {
44904 PyThreadState* __tstate = wxPyBeginAllowThreads();
44905 result = (wxRelationship)(arg1)->GetRelationship();
44906
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 resultobj = SWIG_From_int((result));
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44918 PyObject *resultobj;
44919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44920 wxRelationship arg2 ;
44921 PyObject * obj0 = 0 ;
44922 PyObject * obj1 = 0 ;
44923 char *kwnames[] = {
44924 (char *) "self",(char *) "r", NULL
44925 };
44926
44927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44929 if (SWIG_arg_fail(1)) SWIG_fail;
44930 {
44931 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44932 if (SWIG_arg_fail(2)) SWIG_fail;
44933 }
44934 {
44935 PyThreadState* __tstate = wxPyBeginAllowThreads();
44936 (arg1)->SetRelationship((wxRelationship )arg2);
44937
44938 wxPyEndAllowThreads(__tstate);
44939 if (PyErr_Occurred()) SWIG_fail;
44940 }
44941 Py_INCREF(Py_None); resultobj = Py_None;
44942 return resultobj;
44943 fail:
44944 return NULL;
44945 }
44946
44947
44948 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44949 PyObject *resultobj;
44950 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44951 wxWindow *arg2 = (wxWindow *) 0 ;
44952 bool result;
44953 PyObject * obj0 = 0 ;
44954 PyObject * obj1 = 0 ;
44955 char *kwnames[] = {
44956 (char *) "self",(char *) "otherW", NULL
44957 };
44958
44959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44963 if (SWIG_arg_fail(2)) SWIG_fail;
44964 {
44965 PyThreadState* __tstate = wxPyBeginAllowThreads();
44966 result = (bool)(arg1)->ResetIfWin(arg2);
44967
44968 wxPyEndAllowThreads(__tstate);
44969 if (PyErr_Occurred()) SWIG_fail;
44970 }
44971 {
44972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44973 }
44974 return resultobj;
44975 fail:
44976 return NULL;
44977 }
44978
44979
44980 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44981 PyObject *resultobj;
44982 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44983 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44984 wxWindow *arg3 = (wxWindow *) 0 ;
44985 bool result;
44986 PyObject * obj0 = 0 ;
44987 PyObject * obj1 = 0 ;
44988 PyObject * obj2 = 0 ;
44989 char *kwnames[] = {
44990 (char *) "self",(char *) "constraints",(char *) "win", NULL
44991 };
44992
44993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44995 if (SWIG_arg_fail(1)) SWIG_fail;
44996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44997 if (SWIG_arg_fail(2)) SWIG_fail;
44998 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44999 if (SWIG_arg_fail(3)) SWIG_fail;
45000 {
45001 PyThreadState* __tstate = wxPyBeginAllowThreads();
45002 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45003
45004 wxPyEndAllowThreads(__tstate);
45005 if (PyErr_Occurred()) SWIG_fail;
45006 }
45007 {
45008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45009 }
45010 return resultobj;
45011 fail:
45012 return NULL;
45013 }
45014
45015
45016 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45017 PyObject *resultobj;
45018 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45019 wxEdge arg2 ;
45020 wxWindow *arg3 = (wxWindow *) 0 ;
45021 wxWindow *arg4 = (wxWindow *) 0 ;
45022 int result;
45023 PyObject * obj0 = 0 ;
45024 PyObject * obj1 = 0 ;
45025 PyObject * obj2 = 0 ;
45026 PyObject * obj3 = 0 ;
45027 char *kwnames[] = {
45028 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45029 };
45030
45031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45033 if (SWIG_arg_fail(1)) SWIG_fail;
45034 {
45035 arg2 = (wxEdge)(SWIG_As_int(obj1));
45036 if (SWIG_arg_fail(2)) SWIG_fail;
45037 }
45038 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45039 if (SWIG_arg_fail(3)) SWIG_fail;
45040 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45041 if (SWIG_arg_fail(4)) SWIG_fail;
45042 {
45043 PyThreadState* __tstate = wxPyBeginAllowThreads();
45044 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45045
45046 wxPyEndAllowThreads(__tstate);
45047 if (PyErr_Occurred()) SWIG_fail;
45048 }
45049 {
45050 resultobj = SWIG_From_int((int)(result));
45051 }
45052 return resultobj;
45053 fail:
45054 return NULL;
45055 }
45056
45057
45058 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45059 PyObject *obj;
45060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45061 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45062 Py_INCREF(obj);
45063 return Py_BuildValue((char *)"");
45064 }
45065 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45066 PyObject *resultobj;
45067 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45068 wxIndividualLayoutConstraint *result;
45069 PyObject * obj0 = 0 ;
45070 char *kwnames[] = {
45071 (char *) "self", NULL
45072 };
45073
45074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45076 if (SWIG_arg_fail(1)) SWIG_fail;
45077 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45078
45079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45080 return resultobj;
45081 fail:
45082 return NULL;
45083 }
45084
45085
45086 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45087 PyObject *resultobj;
45088 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45089 wxIndividualLayoutConstraint *result;
45090 PyObject * obj0 = 0 ;
45091 char *kwnames[] = {
45092 (char *) "self", NULL
45093 };
45094
45095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45097 if (SWIG_arg_fail(1)) SWIG_fail;
45098 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45099
45100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45101 return resultobj;
45102 fail:
45103 return NULL;
45104 }
45105
45106
45107 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45108 PyObject *resultobj;
45109 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45110 wxIndividualLayoutConstraint *result;
45111 PyObject * obj0 = 0 ;
45112 char *kwnames[] = {
45113 (char *) "self", NULL
45114 };
45115
45116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45118 if (SWIG_arg_fail(1)) SWIG_fail;
45119 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45120
45121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45122 return resultobj;
45123 fail:
45124 return NULL;
45125 }
45126
45127
45128 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45129 PyObject *resultobj;
45130 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45131 wxIndividualLayoutConstraint *result;
45132 PyObject * obj0 = 0 ;
45133 char *kwnames[] = {
45134 (char *) "self", NULL
45135 };
45136
45137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45139 if (SWIG_arg_fail(1)) SWIG_fail;
45140 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45141
45142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45143 return resultobj;
45144 fail:
45145 return NULL;
45146 }
45147
45148
45149 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45150 PyObject *resultobj;
45151 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45152 wxIndividualLayoutConstraint *result;
45153 PyObject * obj0 = 0 ;
45154 char *kwnames[] = {
45155 (char *) "self", NULL
45156 };
45157
45158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45160 if (SWIG_arg_fail(1)) SWIG_fail;
45161 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45162
45163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45164 return resultobj;
45165 fail:
45166 return NULL;
45167 }
45168
45169
45170 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45171 PyObject *resultobj;
45172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45173 wxIndividualLayoutConstraint *result;
45174 PyObject * obj0 = 0 ;
45175 char *kwnames[] = {
45176 (char *) "self", NULL
45177 };
45178
45179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45181 if (SWIG_arg_fail(1)) SWIG_fail;
45182 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45183
45184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45185 return resultobj;
45186 fail:
45187 return NULL;
45188 }
45189
45190
45191 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45192 PyObject *resultobj;
45193 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45194 wxIndividualLayoutConstraint *result;
45195 PyObject * obj0 = 0 ;
45196 char *kwnames[] = {
45197 (char *) "self", NULL
45198 };
45199
45200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45202 if (SWIG_arg_fail(1)) SWIG_fail;
45203 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45204
45205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45206 return resultobj;
45207 fail:
45208 return NULL;
45209 }
45210
45211
45212 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45213 PyObject *resultobj;
45214 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45215 wxIndividualLayoutConstraint *result;
45216 PyObject * obj0 = 0 ;
45217 char *kwnames[] = {
45218 (char *) "self", NULL
45219 };
45220
45221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45223 if (SWIG_arg_fail(1)) SWIG_fail;
45224 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45225
45226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45234 PyObject *resultobj;
45235 wxLayoutConstraints *result;
45236 char *kwnames[] = {
45237 NULL
45238 };
45239
45240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45241 {
45242 PyThreadState* __tstate = wxPyBeginAllowThreads();
45243 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45244
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45256 PyObject *resultobj;
45257 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45258 wxWindow *arg2 = (wxWindow *) 0 ;
45259 int *arg3 = (int *) 0 ;
45260 bool result;
45261 int temp3 ;
45262 int res3 = 0 ;
45263 PyObject * obj0 = 0 ;
45264 PyObject * obj1 = 0 ;
45265 char *kwnames[] = {
45266 (char *) "self",(char *) "win", NULL
45267 };
45268
45269 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45272 if (SWIG_arg_fail(1)) SWIG_fail;
45273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45274 if (SWIG_arg_fail(2)) SWIG_fail;
45275 {
45276 PyThreadState* __tstate = wxPyBeginAllowThreads();
45277 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45278
45279 wxPyEndAllowThreads(__tstate);
45280 if (PyErr_Occurred()) SWIG_fail;
45281 }
45282 {
45283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45284 }
45285 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45286 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45287 return resultobj;
45288 fail:
45289 return NULL;
45290 }
45291
45292
45293 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45294 PyObject *resultobj;
45295 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45296 bool result;
45297 PyObject * obj0 = 0 ;
45298 char *kwnames[] = {
45299 (char *) "self", NULL
45300 };
45301
45302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) 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 {
45306 PyThreadState* __tstate = wxPyBeginAllowThreads();
45307 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45308
45309 wxPyEndAllowThreads(__tstate);
45310 if (PyErr_Occurred()) SWIG_fail;
45311 }
45312 {
45313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45314 }
45315 return resultobj;
45316 fail:
45317 return NULL;
45318 }
45319
45320
45321 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45322 PyObject *obj;
45323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45324 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45325 Py_INCREF(obj);
45326 return Py_BuildValue((char *)"");
45327 }
45328 static PyMethodDef SwigMethods[] = {
45329 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45330 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45331 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45334 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45355 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45368 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45383 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45437 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45465 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45484 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45486 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45494 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45495 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45507 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45519 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45523 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45529 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45539 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45549 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45556 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45636 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45638 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45640 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45646 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45648 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45650 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45656 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45658 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45660 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45674 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45692 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45695 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45698 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45710 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45715 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45721 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45727 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45790 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45797 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45833 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45843 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45849 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45851 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45853 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45856 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45860 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45863 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45866 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45868 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45873 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45881 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45885 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45888 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45890 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45894 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45911 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45913 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45916 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45918 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45922 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45926 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45937 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45940 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45943 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45947 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45954 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45959 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45964 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46013 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46033 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46040 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46044 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46054 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46226 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46267 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46282 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46285 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46340 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46367 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46411 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46419 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46438 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46439 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46476 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46506 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46509 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46513 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46516 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46526 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46538 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46550 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46560 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46570 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46584 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46591 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46592 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46593 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46594 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46595 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46600 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46627 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46639 { NULL, NULL, 0, NULL }
46640 };
46641
46642
46643 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46644
46645 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46646 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46647 }
46648 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46649 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46650 }
46651 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46652 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46653 }
46654 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46655 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46656 }
46657 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46658 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46659 }
46660 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46661 return (void *)((wxSizer *) ((wxGridSizer *) x));
46662 }
46663 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46664 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46665 }
46666 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46667 return (void *)((wxSizer *) ((wxPySizer *) x));
46668 }
46669 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46670 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46671 }
46672 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46673 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46674 }
46675 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46676 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46677 }
46678 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46679 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46680 }
46681 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46682 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46683 }
46684 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46685 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46686 }
46687 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46688 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46689 }
46690 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46691 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46692 }
46693 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46694 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46695 }
46696 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46697 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46698 }
46699 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46700 return (void *)((wxEvent *) ((wxPyEvent *) x));
46701 }
46702 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46703 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46704 }
46705 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46706 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46707 }
46708 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46709 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46710 }
46711 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46712 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46713 }
46714 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46715 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46716 }
46717 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46718 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46719 }
46720 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46721 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46722 }
46723 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46724 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46725 }
46726 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46727 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46728 }
46729 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46731 }
46732 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46733 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46734 }
46735 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46736 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46737 }
46738 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46739 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46740 }
46741 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46742 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46743 }
46744 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46745 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46746 }
46747 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46748 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46749 }
46750 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46751 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46752 }
46753 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46754 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46755 }
46756 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46757 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46758 }
46759 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46760 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46761 }
46762 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46763 return (void *)((wxEvent *) ((wxShowEvent *) x));
46764 }
46765 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46766 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46767 }
46768 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46769 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46770 }
46771 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46772 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46773 }
46774 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46775 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46776 }
46777 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46778 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46779 }
46780 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46781 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46782 }
46783 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46784 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46785 }
46786 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46787 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46788 }
46789 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46790 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46791 }
46792 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46793 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46794 }
46795 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46796 return (void *)((wxControl *) ((wxControlWithItems *) x));
46797 }
46798 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46799 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46800 }
46801 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46802 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46803 }
46804 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46805 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46806 }
46807 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46808 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46809 }
46810 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46811 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46812 }
46813 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46814 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46815 }
46816 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46817 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46818 }
46819 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46820 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46821 }
46822 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46823 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46824 }
46825 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46826 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46827 }
46828 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46829 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46830 }
46831 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46832 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46833 }
46834 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46835 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46836 }
46837 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46838 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46839 }
46840 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46841 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46842 }
46843 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46844 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46845 }
46846 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46847 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46848 }
46849 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46850 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46851 }
46852 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46853 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46854 }
46855 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46856 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46857 }
46858 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46859 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46860 }
46861 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46862 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46863 }
46864 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46865 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46866 }
46867 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46868 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46869 }
46870 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46871 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46872 }
46873 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46874 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46875 }
46876 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46877 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46878 }
46879 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46880 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46881 }
46882 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46883 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46884 }
46885 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46886 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46887 }
46888 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46889 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46890 }
46891 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46892 return (void *)((wxObject *) ((wxSizerItem *) x));
46893 }
46894 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46895 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46896 }
46897 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46898 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46899 }
46900 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46901 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46902 }
46903 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46904 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46905 }
46906 static void *_p_wxSizerTo_p_wxObject(void *x) {
46907 return (void *)((wxObject *) ((wxSizer *) x));
46908 }
46909 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46910 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46911 }
46912 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46913 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46914 }
46915 static void *_p_wxEventTo_p_wxObject(void *x) {
46916 return (void *)((wxObject *) ((wxEvent *) x));
46917 }
46918 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46919 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46920 }
46921 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46922 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46923 }
46924 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46925 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46926 }
46927 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46928 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46929 }
46930 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46931 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46932 }
46933 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46934 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46935 }
46936 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46937 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46938 }
46939 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46940 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46941 }
46942 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46943 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46944 }
46945 static void *_p_wxControlTo_p_wxObject(void *x) {
46946 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46947 }
46948 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46949 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46950 }
46951 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46952 return (void *)((wxObject *) ((wxFSFile *) x));
46953 }
46954 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46955 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46956 }
46957 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46958 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46959 }
46960 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46961 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46962 }
46963 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46964 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46965 }
46966 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46967 return (void *)((wxObject *) ((wxMenuItem *) x));
46968 }
46969 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46971 }
46972 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46973 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46974 }
46975 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46976 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46977 }
46978 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46979 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46980 }
46981 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46982 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46983 }
46984 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46985 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46986 }
46987 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46988 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46989 }
46990 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46991 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46992 }
46993 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46994 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46995 }
46996 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46997 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46998 }
46999 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47000 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47001 }
47002 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47003 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47004 }
47005 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47006 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47007 }
47008 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47009 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47010 }
47011 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47012 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47013 }
47014 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47015 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47016 }
47017 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47018 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47019 }
47020 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47021 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47022 }
47023 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47024 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47025 }
47026 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47027 return (void *)((wxObject *) ((wxImageHandler *) x));
47028 }
47029 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47030 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47031 }
47032 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47033 return (void *)((wxObject *) ((wxEvtHandler *) x));
47034 }
47035 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47036 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47037 }
47038 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47039 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47040 }
47041 static void *_p_wxImageTo_p_wxObject(void *x) {
47042 return (void *)((wxObject *) ((wxImage *) x));
47043 }
47044 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47045 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47046 }
47047 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47048 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47049 }
47050 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47051 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47052 }
47053 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47054 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47055 }
47056 static void *_p_wxWindowTo_p_wxObject(void *x) {
47057 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47058 }
47059 static void *_p_wxMenuTo_p_wxObject(void *x) {
47060 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47061 }
47062 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47063 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47064 }
47065 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47066 return (void *)((wxObject *) ((wxFileSystem *) x));
47067 }
47068 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47069 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47070 }
47071 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47072 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47073 }
47074 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47075 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47076 }
47077 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47078 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47079 }
47080 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47081 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47082 }
47083 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47084 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47085 }
47086 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47087 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47088 }
47089 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47090 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47091 }
47092 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47093 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47094 }
47095 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47096 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47097 }
47098 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47099 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47100 }
47101 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47102 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47103 }
47104 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47105 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47106 }
47107 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47108 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47109 }
47110 static void *_p_wxControlTo_p_wxWindow(void *x) {
47111 return (void *)((wxWindow *) ((wxControl *) x));
47112 }
47113 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47114 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47115 }
47116 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47117 return (void *)((wxWindow *) ((wxMenuBar *) x));
47118 }
47119 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47120 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47121 }
47122 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47123 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47124 }
47125 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47126 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47127 }
47128 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47129 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47130 }
47131 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47132 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47133 }
47134 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47135 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47136 }
47137 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47138 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47139 }
47140 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47141 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47142 }
47143 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47144 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47145 }
47146 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47147 return (void *)((wxValidator *) ((wxPyValidator *) x));
47148 }
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277
47278 static swig_type_info *swig_types_initial[] = {
47279 _swigt__p_wxLayoutConstraints,
47280 _swigt__p_wxRealPoint,
47281 _swigt__p_wxSizerItem,
47282 _swigt__p_wxGBSizerItem,
47283 _swigt__p_wxScrollEvent,
47284 _swigt__p_wxEventLoop,
47285 _swigt__p_wxIndividualLayoutConstraint,
47286 _swigt__p_wxSizer,
47287 _swigt__p_wxBoxSizer,
47288 _swigt__p_wxStaticBoxSizer,
47289 _swigt__p_wxGridBagSizer,
47290 _swigt__p_wxAcceleratorEntry,
47291 _swigt__p_wxUpdateUIEvent,
47292 _swigt__p_wxEvent,
47293 _swigt__p_buffer,
47294 _swigt__p_wxMenu,
47295 _swigt__p_wxGridSizer,
47296 _swigt__p_wxFlexGridSizer,
47297 _swigt__p_wxInitDialogEvent,
47298 _swigt__p_wxItemContainer,
47299 _swigt__p_wxNcPaintEvent,
47300 _swigt__p_wxPaintEvent,
47301 _swigt__p_wxSysColourChangedEvent,
47302 _swigt__p_wxMouseCaptureChangedEvent,
47303 _swigt__p_wxDisplayChangedEvent,
47304 _swigt__p_wxPaletteChangedEvent,
47305 _swigt__p_wxControl,
47306 _swigt__p_wxFont,
47307 _swigt__p_wxMenuBarBase,
47308 _swigt__p_wxSetCursorEvent,
47309 _swigt__p_wxFSFile,
47310 _swigt__p_wxCaret,
47311 _swigt__ptrdiff_t,
47312 _swigt__std__ptrdiff_t,
47313 _swigt__p_wxRegion,
47314 _swigt__p_wxPoint2D,
47315 _swigt__p_int,
47316 _swigt__p_wxSize,
47317 _swigt__p_wxDC,
47318 _swigt__p_wxPySizer,
47319 _swigt__p_wxVisualAttributes,
47320 _swigt__p_wxNotifyEvent,
47321 _swigt__p_wxPyEvent,
47322 _swigt__p_wxPropagationDisabler,
47323 _swigt__p_form_ops_t,
47324 _swigt__p_wxAppTraits,
47325 _swigt__p_wxArrayString,
47326 _swigt__p_wxShowEvent,
47327 _swigt__p_wxToolTip,
47328 _swigt__p_wxMoveEvent,
47329 _swigt__p_wxSizeEvent,
47330 _swigt__p_wxActivateEvent,
47331 _swigt__p_wxIconizeEvent,
47332 _swigt__p_wxMaximizeEvent,
47333 _swigt__p_wxQueryNewPaletteEvent,
47334 _swigt__p_wxWindowCreateEvent,
47335 _swigt__p_wxIdleEvent,
47336 _swigt__p_wxDateEvent,
47337 _swigt__p_wxMenuItem,
47338 _swigt__p_wxStaticBox,
47339 _swigt__p_long,
47340 _swigt__p_wxDuplexMode,
47341 _swigt__p_wxTIFFHandler,
47342 _swigt__p_wxXPMHandler,
47343 _swigt__p_wxPNMHandler,
47344 _swigt__p_wxJPEGHandler,
47345 _swigt__p_wxPCXHandler,
47346 _swigt__p_wxGIFHandler,
47347 _swigt__p_wxPNGHandler,
47348 _swigt__p_wxANIHandler,
47349 _swigt__p_wxMemoryFSHandler,
47350 _swigt__p_wxZipFSHandler,
47351 _swigt__p_wxInternetFSHandler,
47352 _swigt__p_wxPyFileSystemHandler,
47353 _swigt__p_wxEvtHandler,
47354 _swigt__p_wxCURHandler,
47355 _swigt__p_wxICOHandler,
47356 _swigt__p_wxBMPHandler,
47357 _swigt__p_wxImageHandler,
47358 _swigt__p_wxFileSystemHandler,
47359 _swigt__p_wxRect,
47360 _swigt__p_wxButton,
47361 _swigt__p_wxGBSpan,
47362 _swigt__p_wxPropagateOnce,
47363 _swigt__p_wxAcceleratorTable,
47364 _swigt__p_wxStdDialogButtonSizer,
47365 _swigt__p_char,
47366 _swigt__p_wxGBPosition,
47367 _swigt__p_wxImage,
47368 _swigt__p_wxFrame,
47369 _swigt__p_wxScrollWinEvent,
47370 _swigt__p_wxPaperSize,
47371 _swigt__p_wxImageHistogram,
47372 _swigt__p_wxPoint,
47373 _swigt__p_wxCursor,
47374 _swigt__p_wxObject,
47375 _swigt__p_wxInputStream,
47376 _swigt__p_wxOutputStream,
47377 _swigt__p_wxPyInputStream,
47378 _swigt__p_wxDateTime,
47379 _swigt__p_wxKeyEvent,
47380 _swigt__p_wxNavigationKeyEvent,
47381 _swigt__p_wxWindowDestroyEvent,
47382 _swigt__p_unsigned_long,
47383 _swigt__p_wxWindow,
47384 _swigt__p_wxMenuBar,
47385 _swigt__p_wxFileSystem,
47386 _swigt__p_wxBitmap,
47387 _swigt__unsigned_int,
47388 _swigt__p_unsigned_int,
47389 _swigt__p_wxMenuEvent,
47390 _swigt__p_wxContextMenuEvent,
47391 _swigt__p_unsigned_char,
47392 _swigt__p_wxEraseEvent,
47393 _swigt__p_wxMouseEvent,
47394 _swigt__p_wxCloseEvent,
47395 _swigt__p_wxPyApp,
47396 _swigt__p_wxCommandEvent,
47397 _swigt__p_wxPyCommandEvent,
47398 _swigt__p_wxPyDropTarget,
47399 _swigt__p_wxQuantize,
47400 _swigt__p_wxFocusEvent,
47401 _swigt__p_wxChildFocusEvent,
47402 _swigt__p_wxDropFilesEvent,
47403 _swigt__p_wxControlWithItems,
47404 _swigt__p_wxColour,
47405 _swigt__p_wxValidator,
47406 _swigt__p_wxPyValidator,
47407 0
47408 };
47409
47410
47411 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47412
47413 static swig_const_info swig_const_table[] = {
47414 {0, 0, 0, 0.0, 0, 0}};
47415
47416 #ifdef __cplusplus
47417 }
47418 #endif
47419
47420
47421 #ifdef __cplusplus
47422 extern "C" {
47423 #endif
47424
47425 /* Python-specific SWIG API */
47426 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47427 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47428 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47429
47430 /* -----------------------------------------------------------------------------
47431 * global variable support code.
47432 * ----------------------------------------------------------------------------- */
47433
47434 typedef struct swig_globalvar {
47435 char *name; /* Name of global variable */
47436 PyObject *(*get_attr)(); /* Return the current value */
47437 int (*set_attr)(PyObject *); /* Set the value */
47438 struct swig_globalvar *next;
47439 } swig_globalvar;
47440
47441 typedef struct swig_varlinkobject {
47442 PyObject_HEAD
47443 swig_globalvar *vars;
47444 } swig_varlinkobject;
47445
47446 static PyObject *
47447 swig_varlink_repr(swig_varlinkobject *v) {
47448 v = v;
47449 return PyString_FromString("<Swig global variables>");
47450 }
47451
47452 static int
47453 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47454 swig_globalvar *var;
47455 flags = flags;
47456 fprintf(fp,"Swig global variables { ");
47457 for (var = v->vars; var; var=var->next) {
47458 fprintf(fp,"%s", var->name);
47459 if (var->next) fprintf(fp,", ");
47460 }
47461 fprintf(fp," }\n");
47462 return 0;
47463 }
47464
47465 static PyObject *
47466 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47467 swig_globalvar *var = v->vars;
47468 while (var) {
47469 if (strcmp(var->name,n) == 0) {
47470 return (*var->get_attr)();
47471 }
47472 var = var->next;
47473 }
47474 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47475 return NULL;
47476 }
47477
47478 static int
47479 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47480 swig_globalvar *var = v->vars;
47481 while (var) {
47482 if (strcmp(var->name,n) == 0) {
47483 return (*var->set_attr)(p);
47484 }
47485 var = var->next;
47486 }
47487 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47488 return 1;
47489 }
47490
47491 static PyTypeObject varlinktype = {
47492 PyObject_HEAD_INIT(0)
47493 0, /* Number of items in variable part (ob_size) */
47494 (char *)"swigvarlink", /* Type name (tp_name) */
47495 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47496 0, /* Itemsize (tp_itemsize) */
47497 0, /* Deallocator (tp_dealloc) */
47498 (printfunc) swig_varlink_print, /* Print (tp_print) */
47499 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47500 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47501 0, /* tp_compare */
47502 (reprfunc) swig_varlink_repr, /* tp_repr */
47503 0, /* tp_as_number */
47504 0, /* tp_as_sequence */
47505 0, /* tp_as_mapping */
47506 0, /* tp_hash */
47507 0, /* tp_call */
47508 0, /* tp_str */
47509 0, /* tp_getattro */
47510 0, /* tp_setattro */
47511 0, /* tp_as_buffer */
47512 0, /* tp_flags */
47513 0, /* tp_doc */
47514 #if PY_VERSION_HEX >= 0x02000000
47515 0, /* tp_traverse */
47516 0, /* tp_clear */
47517 #endif
47518 #if PY_VERSION_HEX >= 0x02010000
47519 0, /* tp_richcompare */
47520 0, /* tp_weaklistoffset */
47521 #endif
47522 #if PY_VERSION_HEX >= 0x02020000
47523 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47524 #endif
47525 #if PY_VERSION_HEX >= 0x02030000
47526 0, /* tp_del */
47527 #endif
47528 #ifdef COUNT_ALLOCS
47529 0,0,0,0 /* tp_alloc -> tp_next */
47530 #endif
47531 };
47532
47533 /* Create a variable linking object for use later */
47534 static PyObject *
47535 SWIG_Python_newvarlink(void) {
47536 swig_varlinkobject *result = 0;
47537 result = PyMem_NEW(swig_varlinkobject,1);
47538 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47539 result->ob_type = &varlinktype;
47540 result->vars = 0;
47541 result->ob_refcnt = 0;
47542 Py_XINCREF((PyObject *) result);
47543 return ((PyObject*) result);
47544 }
47545
47546 static void
47547 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47548 swig_varlinkobject *v;
47549 swig_globalvar *gv;
47550 v= (swig_varlinkobject *) p;
47551 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47552 gv->name = (char *) malloc(strlen(name)+1);
47553 strcpy(gv->name,name);
47554 gv->get_attr = get_attr;
47555 gv->set_attr = set_attr;
47556 gv->next = v->vars;
47557 v->vars = gv;
47558 }
47559
47560 /* -----------------------------------------------------------------------------
47561 * constants/methods manipulation
47562 * ----------------------------------------------------------------------------- */
47563
47564 /* Install Constants */
47565 static void
47566 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47567 PyObject *obj = 0;
47568 size_t i;
47569 for (i = 0; constants[i].type; i++) {
47570 switch(constants[i].type) {
47571 case SWIG_PY_INT:
47572 obj = PyInt_FromLong(constants[i].lvalue);
47573 break;
47574 case SWIG_PY_FLOAT:
47575 obj = PyFloat_FromDouble(constants[i].dvalue);
47576 break;
47577 case SWIG_PY_STRING:
47578 if (constants[i].pvalue) {
47579 obj = PyString_FromString((char *) constants[i].pvalue);
47580 } else {
47581 Py_INCREF(Py_None);
47582 obj = Py_None;
47583 }
47584 break;
47585 case SWIG_PY_POINTER:
47586 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47587 break;
47588 case SWIG_PY_BINARY:
47589 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47590 break;
47591 default:
47592 obj = 0;
47593 break;
47594 }
47595 if (obj) {
47596 PyDict_SetItemString(d,constants[i].name,obj);
47597 Py_DECREF(obj);
47598 }
47599 }
47600 }
47601
47602 /* -----------------------------------------------------------------------------*/
47603 /* Fix SwigMethods to carry the callback ptrs when needed */
47604 /* -----------------------------------------------------------------------------*/
47605
47606 static void
47607 SWIG_Python_FixMethods(PyMethodDef *methods,
47608 swig_const_info *const_table,
47609 swig_type_info **types,
47610 swig_type_info **types_initial) {
47611 size_t i;
47612 for (i = 0; methods[i].ml_name; ++i) {
47613 char *c = methods[i].ml_doc;
47614 if (c && (c = strstr(c, "swig_ptr: "))) {
47615 int j;
47616 swig_const_info *ci = 0;
47617 char *name = c + 10;
47618 for (j = 0; const_table[j].type; j++) {
47619 if (strncmp(const_table[j].name, name,
47620 strlen(const_table[j].name)) == 0) {
47621 ci = &(const_table[j]);
47622 break;
47623 }
47624 }
47625 if (ci) {
47626 size_t shift = (ci->ptype) - types;
47627 swig_type_info *ty = types_initial[shift];
47628 size_t ldoc = (c - methods[i].ml_doc);
47629 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47630 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47631 char *buff = ndoc;
47632 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47633 strncpy(buff, methods[i].ml_doc, ldoc);
47634 buff += ldoc;
47635 strncpy(buff, "swig_ptr: ", 10);
47636 buff += 10;
47637 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47638 methods[i].ml_doc = ndoc;
47639 }
47640 }
47641 }
47642 }
47643
47644 /* -----------------------------------------------------------------------------*
47645 * Initialize type list
47646 * -----------------------------------------------------------------------------*/
47647
47648 #if PY_MAJOR_VERSION < 2
47649 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47650 is copied out of Python/modsupport.c in python version 2.3.4 */
47651 static int
47652 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47653 {
47654 PyObject *dict;
47655 if (!PyModule_Check(m)) {
47656 PyErr_SetString(PyExc_TypeError,
47657 "PyModule_AddObject() needs module as first arg");
47658 return -1;
47659 }
47660 if (!o) {
47661 PyErr_SetString(PyExc_TypeError,
47662 "PyModule_AddObject() needs non-NULL value");
47663 return -1;
47664 }
47665
47666 dict = PyModule_GetDict(m);
47667 if (dict == NULL) {
47668 /* Internal error -- modules must have a dict! */
47669 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47670 PyModule_GetName(m));
47671 return -1;
47672 }
47673 if (PyDict_SetItemString(dict, name, o))
47674 return -1;
47675 Py_DECREF(o);
47676 return 0;
47677 }
47678 #endif
47679
47680 static swig_type_info **
47681 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47682 static PyMethodDef swig_empty_runtime_method_table[] = {
47683 {
47684 NULL, NULL, 0, NULL
47685 }
47686 };/* Sentinel */
47687
47688 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47689 swig_empty_runtime_method_table);
47690 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47691 if (pointer && module) {
47692 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47693 }
47694 return type_list_handle;
47695 }
47696
47697 static swig_type_info **
47698 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47699 swig_type_info **type_pointer;
47700
47701 /* first check if module already created */
47702 type_pointer = SWIG_Python_GetTypeListHandle();
47703 if (type_pointer) {
47704 return type_pointer;
47705 } else {
47706 /* create a new module and variable */
47707 return SWIG_Python_SetTypeListHandle(type_list_handle);
47708 }
47709 }
47710
47711 #ifdef __cplusplus
47712 }
47713 #endif
47714
47715 /* -----------------------------------------------------------------------------*
47716 * Partial Init method
47717 * -----------------------------------------------------------------------------*/
47718
47719 #ifdef SWIG_LINK_RUNTIME
47720 #ifdef __cplusplus
47721 extern "C"
47722 #endif
47723 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47724 #endif
47725
47726 #ifdef __cplusplus
47727 extern "C"
47728 #endif
47729 SWIGEXPORT(void) SWIG_init(void) {
47730 static PyObject *SWIG_globals = 0;
47731 static int typeinit = 0;
47732 PyObject *m, *d;
47733 int i;
47734 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47735
47736 /* Fix SwigMethods to carry the callback ptrs when needed */
47737 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47738
47739 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47740 d = PyModule_GetDict(m);
47741
47742 if (!typeinit) {
47743 #ifdef SWIG_LINK_RUNTIME
47744 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47745 #else
47746 # ifndef SWIG_STATIC_RUNTIME
47747 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47748 # endif
47749 #endif
47750 for (i = 0; swig_types_initial[i]; i++) {
47751 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47752 }
47753 typeinit = 1;
47754 }
47755 SWIG_InstallConstants(d,swig_const_table);
47756
47757
47758 #ifndef wxPyUSE_EXPORT
47759 // Make our API structure a CObject so other modules can import it
47760 // from this module.
47761 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47762 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47763 Py_XDECREF(cobj);
47764 #endif
47765
47766 {
47767 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49430 }
49431 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49432 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49433 {
49434 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49585 }
49586 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49587 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49588 {
49589 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49596 }
49597
49598 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49599
49600
49601 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49602
49603 {
49604 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49611 }
49612 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49613 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49614 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49615 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49616 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49617 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49618 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49619 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49620 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49621 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49622 {
49623 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49627 }
49628 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49629 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49630 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49631 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49632 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49633 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49634 {
49635 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49681 }
49682 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49683 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49684 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49685 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49686 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49687 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49688 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49689 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49690 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49691 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49692 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49693 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49694 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49695 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49696 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49697 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49698 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49699 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49700 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49701 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49702 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49703 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49704 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49705 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49706 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49707 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49708 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49709 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49710 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49711 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49712 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49713 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49714 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49715 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49716 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49717 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49718 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49719 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49720 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49721 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49722 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49723 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49724 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49725 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49726 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49727 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49728 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49729 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49730 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49731 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49732 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49733 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49734 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49735 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49736 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49737 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49738 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49739 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49740 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49741 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49742 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49743 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49744 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49745 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49746 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49747 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49748 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49749 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49750 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49751 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49752 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49753 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49754 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49755 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49756 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49757 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49758 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49759 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49760 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49761 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49762 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49763 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49764 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49765 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49766 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49767 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49768 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49769 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49770 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49771 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49772 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49773 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49774 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49775 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49776 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49777 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49778 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49779 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49780 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49781 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49782 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49783 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49784 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49785 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49786 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49787 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49788 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49789 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49790 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49791 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49792 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49793 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49794 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49795 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49796 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49797 {
49798 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49835 }
49836 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49837 {
49838 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49854 }
49855 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49856 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49857 {
49858 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49859 }
49860 {
49861 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49868 }
49869 {
49870 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49871 }
49872 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49873 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49874 {
49875 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49882 }
49883 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49884 {
49885 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49886 }
49887 {
49888 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49889 }
49890 {
49891 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49940 }
49941
49942 // Initialize threading, some globals and such
49943 __wxPyPreStart(d);
49944
49945
49946 // Although these are defined in __version__ they need to be here too so
49947 // that an assert can be done to ensure that the wxPython and the wxWindows
49948 // versions match.
49949 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49950 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49951 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49952
49953 }
49954
wxWidgets (Impactor)