]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
replace complicated OS tests with simple ifdef EOVERFLOW in wxString::PrintfV()
[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 PyObject* list = PyList_New(count);
2616
2617 if (!list) {
2618 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2619 return NULL;
2620 }
2621
2622 for (int i=0; i<count; i++) {
2623 PyList_SetItem(list, i, wx2PyString(files[i]));
2624 }
2625 return list;
2626 }
2627
2628
2629 static wxPyApp *new_wxPyApp(){
2630 wxPythonApp = new wxPyApp();
2631 return wxPythonApp;
2632 }
2633 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2634
2635 void wxApp_CleanUp() {
2636 __wxPyCleanup();
2637 }
2638
2639
2640 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2641
2642
2643 SWIGINTERNSHORT int
2644 SWIG_AsCharPtr(PyObject *obj, char **val)
2645 {
2646 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2647 return 1;
2648 }
2649 if (val) {
2650 PyErr_Clear();
2651 SWIG_type_error("char *", obj);
2652 }
2653 return 0;
2654 }
2655
2656
2657 SWIGINTERN PyObject *
2658 SWIG_FromCharPtr(const char* cptr)
2659 {
2660 if (cptr) {
2661 size_t size = strlen(cptr);
2662 if (size > INT_MAX) {
2663 return SWIG_NewPointerObj((char*)(cptr),
2664 SWIG_TypeQuery("char *"), 0);
2665 } else {
2666 if (size != 0) {
2667 return PyString_FromStringAndSize(cptr, size);
2668 } else {
2669 return PyString_FromString(cptr);
2670 }
2671 }
2672 }
2673 Py_INCREF(Py_None);
2674 return Py_None;
2675 }
2676
2677
2678 #ifdef __WXMAC__
2679
2680 // A dummy class that raises an exception if used...
2681 class wxEventLoop
2682 {
2683 public:
2684 wxEventLoop() { wxPyRaiseNotImplemented(); }
2685 int Run() { return 0; }
2686 void Exit(int rc = 0) {}
2687 bool Pending() const { return false; }
2688 bool Dispatch() { return false; }
2689 bool IsRunning() const { return false; }
2690 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2691 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2692 };
2693
2694 #else
2695
2696 #include <wx/evtloop.h>
2697
2698 #endif
2699
2700
2701
2702 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2703 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2704 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2705 static PyObject *wxWindow_GetChildren(wxWindow *self){
2706 wxWindowList& list = self->GetChildren();
2707 return wxPy_ConvertList(&list);
2708 }
2709 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2710 #if wxUSE_HOTKEY
2711 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2712 #else
2713 return false;
2714 #endif
2715 }
2716 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2717
2718
2719
2720 return false;
2721
2722 }
2723 static long wxWindow_GetHandle(wxWindow *self){
2724 return wxPyGetWinHandle(self);
2725 }
2726 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2727 self->AssociateHandle((WXWidget)handle);
2728 }
2729
2730 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2731 return wxWindow::FindWindowById(id, parent);
2732 }
2733
2734 wxWindow* wxFindWindowByName( const wxString& name,
2735 const wxWindow *parent = NULL ) {
2736 return wxWindow::FindWindowByName(name, parent);
2737 }
2738
2739 wxWindow* wxFindWindowByLabel( const wxString& label,
2740 const wxWindow *parent = NULL ) {
2741 return wxWindow::FindWindowByLabel(label, parent);
2742 }
2743
2744
2745 #ifdef __WXMSW__
2746 #include <wx/msw/private.h> // to get wxGetWindowId
2747 #endif
2748
2749
2750 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2751 #ifdef __WXMSW__
2752 WXHWND hWnd = (WXHWND)_hWnd;
2753 long id = wxGetWindowId(hWnd);
2754 wxWindow* win = new wxWindow;
2755 parent->AddChild(win);
2756 win->SetEventHandler(win);
2757 win->SetHWND(hWnd);
2758 win->SetId(id);
2759 win->SubclassWin(hWnd);
2760 win->AdoptAttributesFromHWND();
2761 win->SetupColours();
2762 return win;
2763 #else
2764 wxPyRaiseNotImplemented();
2765 return NULL;
2766 #endif
2767 }
2768
2769
2770 PyObject* GetTopLevelWindows() {
2771 return wxPy_ConvertList(&wxTopLevelWindows);
2772 }
2773
2774
2775 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2776 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2777 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2778
2779 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2780
2781 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2782 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2783 wxMenuItemList& list = self->GetMenuItems();
2784 return wxPy_ConvertList(&list);
2785 }
2786 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2787 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2788 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2789 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2790 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2791 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2792 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2793 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2794 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2795 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2796 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2797 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2798 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2799 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2800 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2801 static const wxString wxPyControlNameStr(wxControlNameStr);
2802 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2803 if (clientData) {
2804 wxPyClientData* data = new wxPyClientData(clientData);
2805 return self->Append(item, data);
2806 } else
2807 return self->Append(item);
2808 }
2809 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2810 if (clientData) {
2811 wxPyClientData* data = new wxPyClientData(clientData);
2812 return self->Insert(item, pos, data);
2813 } else
2814 return self->Insert(item, pos);
2815 }
2816 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2817 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2818 if (data) {
2819 Py_INCREF(data->m_obj);
2820 return data->m_obj;
2821 } else {
2822 Py_INCREF(Py_None);
2823 return Py_None;
2824 }
2825 }
2826 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2827 wxPyClientData* data = new wxPyClientData(clientData);
2828 self->SetClientObject(n, data);
2829 }
2830
2831
2832 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2833 wxPyUserData* data = NULL;
2834 if ( userData ) {
2835 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2836 data = new wxPyUserData(userData);
2837 wxPyEndBlockThreads(blocked);
2838 }
2839 return new wxSizerItem(window, proportion, flag, border, data);
2840 }
2841 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2842 wxPyUserData* data = NULL;
2843 if ( userData ) {
2844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2845 data = new wxPyUserData(userData);
2846 wxPyEndBlockThreads(blocked);
2847 }
2848 return new wxSizerItem(width, height, proportion, flag, border, data);
2849 }
2850 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2851 wxPyUserData* data = NULL;
2852 if ( userData ) {
2853 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2854 data = new wxPyUserData(userData);
2855 wxPyEndBlockThreads(blocked);
2856 }
2857 return new wxSizerItem(sizer, proportion, flag, border, data);
2858 }
2859
2860 #include <float.h>
2861 SWIGINTERN int
2862 SWIG_CheckDoubleInRange(double value, double min_value,
2863 double max_value, const char* errmsg)
2864 {
2865 if (value < min_value) {
2866 if (errmsg) {
2867 PyErr_Format(PyExc_OverflowError,
2868 "value %g is less than %s minimum %g",
2869 value, errmsg, min_value);
2870 }
2871 return 0;
2872 } else if (value > max_value) {
2873 if (errmsg) {
2874 PyErr_Format(PyExc_OverflowError,
2875 "value %g is greater than %s maximum %g",
2876 value, errmsg, max_value);
2877 }
2878 return 0;
2879 }
2880 return 1;
2881 }
2882
2883
2884 SWIGINTERN int
2885 SWIG_AsVal_float(PyObject *obj, float *val)
2886 {
2887 const char* errmsg = val ? "float" : (char*)0;
2888 double v;
2889 if (SWIG_AsVal_double(obj, &v)) {
2890 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2891 if (val) *val = (float)(v);
2892 return 1;
2893 } else {
2894 return 0;
2895 }
2896 } else {
2897 PyErr_Clear();
2898 }
2899 if (val) {
2900 SWIG_type_error(errmsg, obj);
2901 }
2902 return 0;
2903 }
2904
2905
2906 SWIGINTERNSHORT float
2907 SWIG_As_float(PyObject* obj)
2908 {
2909 float v;
2910 if (!SWIG_AsVal_float(obj, &v)) {
2911 /*
2912 this is needed to make valgrind/purify happier.
2913 */
2914 memset((void*)&v, 0, sizeof(float));
2915 }
2916 return v;
2917 }
2918
2919
2920 SWIGINTERNSHORT int
2921 SWIG_Check_float(PyObject* obj)
2922 {
2923 return SWIG_AsVal_float(obj, (float*)0);
2924 }
2925
2926
2927 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2928 #define SWIG_From_float PyFloat_FromDouble
2929 /*@@*/
2930
2931 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2932 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2933 if (data) {
2934 Py_INCREF(data->m_obj);
2935 return data->m_obj;
2936 } else {
2937 Py_INCREF(Py_None);
2938 return Py_None;
2939 }
2940 }
2941
2942 // Figure out the type of the sizer item
2943
2944 struct wxPySizerItemInfo {
2945 wxPySizerItemInfo()
2946 : window(NULL), sizer(NULL), gotSize(false),
2947 size(wxDefaultSize), gotPos(false), pos(-1)
2948 {}
2949
2950 wxWindow* window;
2951 wxSizer* sizer;
2952 bool gotSize;
2953 wxSize size;
2954 bool gotPos;
2955 int pos;
2956 };
2957
2958 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2959
2960 wxPySizerItemInfo info;
2961 wxSize size;
2962 wxSize* sizePtr = &size;
2963
2964 // Find out what the type of the item is
2965 // try wxWindow
2966 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2967 PyErr_Clear();
2968 info.window = NULL;
2969
2970 // try wxSizer
2971 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2972 PyErr_Clear();
2973 info.sizer = NULL;
2974
2975 // try wxSize or (w,h)
2976 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2977 info.size = *sizePtr;
2978 info.gotSize = true;
2979 }
2980
2981 // or a single int
2982 if (checkIdx && PyInt_Check(item)) {
2983 info.pos = PyInt_AsLong(item);
2984 info.gotPos = true;
2985 }
2986 }
2987 }
2988
2989 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2990 // no expected type, figure out what kind of error message to generate
2991 if ( !checkSize && !checkIdx )
2992 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2993 else if ( checkSize && !checkIdx )
2994 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2995 else if ( !checkSize && checkIdx)
2996 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2997 else
2998 // can this one happen?
2999 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
3000 }
3001
3002 return info;
3003 }
3004
3005 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3006 if (!self->GetClientObject())
3007 self->SetClientObject(new wxPyOORClientData(_self));
3008 }
3009 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3010
3011 wxPyUserData* data = NULL;
3012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3013 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3014 if ( userData && (info.window || info.sizer || info.gotSize) )
3015 data = new wxPyUserData(userData);
3016 wxPyEndBlockThreads(blocked);
3017
3018 // Now call the real Add method if a valid item type was found
3019 if ( info.window )
3020 return self->Add(info.window, proportion, flag, border, data);
3021 else if ( info.sizer )
3022 return self->Add(info.sizer, proportion, flag, border, data);
3023 else if (info.gotSize)
3024 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3025 proportion, flag, border, data);
3026 else
3027 return NULL;
3028 }
3029 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3030
3031 wxPyUserData* data = NULL;
3032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3033 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3034 if ( userData && (info.window || info.sizer || info.gotSize) )
3035 data = new wxPyUserData(userData);
3036 wxPyEndBlockThreads(blocked);
3037
3038 // Now call the real Insert method if a valid item type was found
3039 if ( info.window )
3040 return self->Insert(before, info.window, proportion, flag, border, data);
3041 else if ( info.sizer )
3042 return self->Insert(before, info.sizer, proportion, flag, border, data);
3043 else if (info.gotSize)
3044 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3045 proportion, flag, border, data);
3046 else
3047 return NULL;
3048 }
3049 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3050
3051 wxPyUserData* data = NULL;
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3054 if ( userData && (info.window || info.sizer || info.gotSize) )
3055 data = new wxPyUserData(userData);
3056 wxPyEndBlockThreads(blocked);
3057
3058 // Now call the real Prepend method if a valid item type was found
3059 if ( info.window )
3060 return self->Prepend(info.window, proportion, flag, border, data);
3061 else if ( info.sizer )
3062 return self->Prepend(info.sizer, proportion, flag, border, data);
3063 else if (info.gotSize)
3064 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3065 proportion, flag, border, data);
3066 else
3067 return NULL;
3068 }
3069 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 return self->Remove(info.window);
3075 else if ( info.sizer )
3076 return self->Remove(info.sizer);
3077 else if ( info.gotPos )
3078 return self->Remove(info.pos);
3079 else
3080 return false;
3081 }
3082 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 return self->Detach(info.window);
3088 else if ( info.sizer )
3089 return self->Detach(info.sizer);
3090 else if ( info.gotPos )
3091 return self->Detach(info.pos);
3092 else
3093 return false;
3094 }
3095 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3098 wxPyEndBlockThreads(blocked);
3099 if ( info.window )
3100 return self->GetItem(info.window);
3101 else if ( info.sizer )
3102 return self->GetItem(info.sizer);
3103 else if ( info.gotPos )
3104 return self->GetItem(info.pos);
3105 else
3106 return NULL;
3107 }
3108 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3111 wxPyEndBlockThreads(blocked);
3112 if ( info.window )
3113 self->SetItemMinSize(info.window, size);
3114 else if ( info.sizer )
3115 self->SetItemMinSize(info.sizer, size);
3116 else if ( info.gotPos )
3117 self->SetItemMinSize(info.pos, size);
3118 }
3119 static PyObject *wxSizer_GetChildren(wxSizer *self){
3120 wxSizerItemList& list = self->GetChildren();
3121 return wxPy_ConvertList(&list);
3122 }
3123 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3124 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3125 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3126 wxPyEndBlockThreads(blocked);
3127 if ( info.window )
3128 return self->Show(info.window, show, recursive);
3129 else if ( info.sizer )
3130 return self->Show(info.sizer, show, recursive);
3131 else if ( info.gotPos )
3132 return self->Show(info.pos, show);
3133 else
3134 return false;
3135 }
3136 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3139 wxPyEndBlockThreads(blocked);
3140 if ( info.window )
3141 return self->IsShown(info.window);
3142 else if ( info.sizer )
3143 return self->IsShown(info.sizer);
3144 else if ( info.gotPos )
3145 return self->IsShown(info.pos);
3146 else
3147 return false;
3148 }
3149
3150 // See pyclasses.h
3151 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3152 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3153 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3154
3155
3156
3157
3158 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3159 {
3160 if (source == Py_None) {
3161 **obj = wxGBPosition(-1,-1);
3162 return true;
3163 }
3164 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3165 }
3166
3167 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3168 {
3169 if (source == Py_None) {
3170 **obj = wxGBSpan(-1,-1);
3171 return true;
3172 }
3173 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3174 }
3175
3176
3177 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3178 self->SetRow(row);
3179 self->SetCol(col);
3180 }
3181 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3183 PyObject* tup = PyTuple_New(2);
3184 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3185 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3186 wxPyEndBlockThreads(blocked);
3187 return tup;
3188 }
3189 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3190 self->SetRowspan(rowspan);
3191 self->SetColspan(colspan);
3192 }
3193 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3195 PyObject* tup = PyTuple_New(2);
3196 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3197 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3198 wxPyEndBlockThreads(blocked);
3199 return tup;
3200 }
3201 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3202 wxPyUserData* data = NULL;
3203 if ( userData ) {
3204 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 data = new wxPyUserData(userData);
3206 wxPyEndBlockThreads(blocked);
3207 }
3208 return new wxGBSizerItem(window, pos, span, flag, border, data);
3209 }
3210 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3211 wxPyUserData* data = NULL;
3212 if ( userData ) {
3213 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3214 data = new wxPyUserData(userData);
3215 wxPyEndBlockThreads(blocked);
3216 }
3217 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3218 }
3219 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3220 wxPyUserData* data = NULL;
3221 if ( userData ) {
3222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3223 data = new wxPyUserData(userData);
3224 wxPyEndBlockThreads(blocked);
3225 }
3226 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3227 }
3228 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3229 int row, col;
3230 self->GetEndPos(row, col);
3231 return wxGBPosition(row, col);
3232 }
3233 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3234
3235 wxPyUserData* data = NULL;
3236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3238 if ( userData && (info.window || info.sizer || info.gotSize) )
3239 data = new wxPyUserData(userData);
3240 wxPyEndBlockThreads(blocked);
3241
3242 // Now call the real Add method if a valid item type was found
3243 if ( info.window )
3244 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3245 else if ( info.sizer )
3246 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3247 else if (info.gotSize)
3248 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3249 pos, span, flag, border, data);
3250 return NULL;
3251 }
3252
3253
3254 #ifdef __cplusplus
3255 extern "C" {
3256 #endif
3257 static int _wrap_EmptyString_set(PyObject *) {
3258 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3259 return 1;
3260 }
3261
3262
3263 static PyObject *_wrap_EmptyString_get(void) {
3264 PyObject *pyobj;
3265
3266 {
3267 #if wxUSE_UNICODE
3268 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3269 #else
3270 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3271 #endif
3272 }
3273 return pyobj;
3274 }
3275
3276
3277 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxObject *arg1 = (wxObject *) 0 ;
3280 wxString result;
3281 PyObject * obj0 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3288 if (SWIG_arg_fail(1)) SWIG_fail;
3289 {
3290 PyThreadState* __tstate = wxPyBeginAllowThreads();
3291 result = wxObject_GetClassName(arg1);
3292
3293 wxPyEndAllowThreads(__tstate);
3294 if (PyErr_Occurred()) SWIG_fail;
3295 }
3296 {
3297 #if wxUSE_UNICODE
3298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3299 #else
3300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3301 #endif
3302 }
3303 return resultobj;
3304 fail:
3305 return NULL;
3306 }
3307
3308
3309 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3310 PyObject *resultobj;
3311 wxObject *arg1 = (wxObject *) 0 ;
3312 PyObject * obj0 = 0 ;
3313 char *kwnames[] = {
3314 (char *) "self", NULL
3315 };
3316
3317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3319 if (SWIG_arg_fail(1)) SWIG_fail;
3320 {
3321 PyThreadState* __tstate = wxPyBeginAllowThreads();
3322 wxObject_Destroy(arg1);
3323
3324 wxPyEndAllowThreads(__tstate);
3325 if (PyErr_Occurred()) SWIG_fail;
3326 }
3327 Py_INCREF(Py_None); resultobj = Py_None;
3328 return resultobj;
3329 fail:
3330 return NULL;
3331 }
3332
3333
3334 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3335 PyObject *obj;
3336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3337 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3338 Py_INCREF(obj);
3339 return Py_BuildValue((char *)"");
3340 }
3341 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3342 PyObject *resultobj;
3343 wxSize *arg1 = (wxSize *) 0 ;
3344 int arg2 ;
3345 PyObject * obj0 = 0 ;
3346 PyObject * obj1 = 0 ;
3347 char *kwnames[] = {
3348 (char *) "self",(char *) "x", NULL
3349 };
3350
3351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3353 if (SWIG_arg_fail(1)) SWIG_fail;
3354 {
3355 arg2 = (int)(SWIG_As_int(obj1));
3356 if (SWIG_arg_fail(2)) SWIG_fail;
3357 }
3358 if (arg1) (arg1)->x = arg2;
3359
3360 Py_INCREF(Py_None); resultobj = Py_None;
3361 return resultobj;
3362 fail:
3363 return NULL;
3364 }
3365
3366
3367 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3368 PyObject *resultobj;
3369 wxSize *arg1 = (wxSize *) 0 ;
3370 int result;
3371 PyObject * obj0 = 0 ;
3372 char *kwnames[] = {
3373 (char *) "self", NULL
3374 };
3375
3376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3378 if (SWIG_arg_fail(1)) SWIG_fail;
3379 result = (int) ((arg1)->x);
3380
3381 {
3382 resultobj = SWIG_From_int((int)(result));
3383 }
3384 return resultobj;
3385 fail:
3386 return NULL;
3387 }
3388
3389
3390 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3391 PyObject *resultobj;
3392 wxSize *arg1 = (wxSize *) 0 ;
3393 int arg2 ;
3394 PyObject * obj0 = 0 ;
3395 PyObject * obj1 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "self",(char *) "y", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3402 if (SWIG_arg_fail(1)) SWIG_fail;
3403 {
3404 arg2 = (int)(SWIG_As_int(obj1));
3405 if (SWIG_arg_fail(2)) SWIG_fail;
3406 }
3407 if (arg1) (arg1)->y = arg2;
3408
3409 Py_INCREF(Py_None); resultobj = Py_None;
3410 return resultobj;
3411 fail:
3412 return NULL;
3413 }
3414
3415
3416 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj;
3418 wxSize *arg1 = (wxSize *) 0 ;
3419 int result;
3420 PyObject * obj0 = 0 ;
3421 char *kwnames[] = {
3422 (char *) "self", NULL
3423 };
3424
3425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3427 if (SWIG_arg_fail(1)) SWIG_fail;
3428 result = (int) ((arg1)->y);
3429
3430 {
3431 resultobj = SWIG_From_int((int)(result));
3432 }
3433 return resultobj;
3434 fail:
3435 return NULL;
3436 }
3437
3438
3439 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3440 PyObject *resultobj;
3441 int arg1 = (int) 0 ;
3442 int arg2 = (int) 0 ;
3443 wxSize *result;
3444 PyObject * obj0 = 0 ;
3445 PyObject * obj1 = 0 ;
3446 char *kwnames[] = {
3447 (char *) "w",(char *) "h", NULL
3448 };
3449
3450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3451 if (obj0) {
3452 {
3453 arg1 = (int)(SWIG_As_int(obj0));
3454 if (SWIG_arg_fail(1)) SWIG_fail;
3455 }
3456 }
3457 if (obj1) {
3458 {
3459 arg2 = (int)(SWIG_As_int(obj1));
3460 if (SWIG_arg_fail(2)) SWIG_fail;
3461 }
3462 }
3463 {
3464 PyThreadState* __tstate = wxPyBeginAllowThreads();
3465 result = (wxSize *)new wxSize(arg1,arg2);
3466
3467 wxPyEndAllowThreads(__tstate);
3468 if (PyErr_Occurred()) SWIG_fail;
3469 }
3470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3471 return resultobj;
3472 fail:
3473 return NULL;
3474 }
3475
3476
3477 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3478 PyObject *resultobj;
3479 wxSize *arg1 = (wxSize *) 0 ;
3480 PyObject * obj0 = 0 ;
3481 char *kwnames[] = {
3482 (char *) "self", NULL
3483 };
3484
3485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3487 if (SWIG_arg_fail(1)) SWIG_fail;
3488 {
3489 PyThreadState* __tstate = wxPyBeginAllowThreads();
3490 delete arg1;
3491
3492 wxPyEndAllowThreads(__tstate);
3493 if (PyErr_Occurred()) SWIG_fail;
3494 }
3495 Py_INCREF(Py_None); resultobj = Py_None;
3496 return resultobj;
3497 fail:
3498 return NULL;
3499 }
3500
3501
3502 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3503 PyObject *resultobj;
3504 wxSize *arg1 = (wxSize *) 0 ;
3505 wxSize *arg2 = 0 ;
3506 bool result;
3507 wxSize temp2 ;
3508 PyObject * obj0 = 0 ;
3509 PyObject * obj1 = 0 ;
3510 char *kwnames[] = {
3511 (char *) "self",(char *) "sz", NULL
3512 };
3513
3514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3516 if (SWIG_arg_fail(1)) SWIG_fail;
3517 {
3518 arg2 = &temp2;
3519 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3520 }
3521 {
3522 PyThreadState* __tstate = wxPyBeginAllowThreads();
3523 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3524
3525 wxPyEndAllowThreads(__tstate);
3526 if (PyErr_Occurred()) SWIG_fail;
3527 }
3528 {
3529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3530 }
3531 return resultobj;
3532 fail:
3533 return NULL;
3534 }
3535
3536
3537 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3538 PyObject *resultobj;
3539 wxSize *arg1 = (wxSize *) 0 ;
3540 wxSize *arg2 = 0 ;
3541 bool result;
3542 wxSize temp2 ;
3543 PyObject * obj0 = 0 ;
3544 PyObject * obj1 = 0 ;
3545 char *kwnames[] = {
3546 (char *) "self",(char *) "sz", NULL
3547 };
3548
3549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3551 if (SWIG_arg_fail(1)) SWIG_fail;
3552 {
3553 arg2 = &temp2;
3554 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3555 }
3556 {
3557 PyThreadState* __tstate = wxPyBeginAllowThreads();
3558 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3559
3560 wxPyEndAllowThreads(__tstate);
3561 if (PyErr_Occurred()) SWIG_fail;
3562 }
3563 {
3564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3565 }
3566 return resultobj;
3567 fail:
3568 return NULL;
3569 }
3570
3571
3572 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3573 PyObject *resultobj;
3574 wxSize *arg1 = (wxSize *) 0 ;
3575 wxSize *arg2 = 0 ;
3576 wxSize result;
3577 wxSize temp2 ;
3578 PyObject * obj0 = 0 ;
3579 PyObject * obj1 = 0 ;
3580 char *kwnames[] = {
3581 (char *) "self",(char *) "sz", NULL
3582 };
3583
3584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3586 if (SWIG_arg_fail(1)) SWIG_fail;
3587 {
3588 arg2 = &temp2;
3589 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3590 }
3591 {
3592 PyThreadState* __tstate = wxPyBeginAllowThreads();
3593 result = (arg1)->operator +((wxSize const &)*arg2);
3594
3595 wxPyEndAllowThreads(__tstate);
3596 if (PyErr_Occurred()) SWIG_fail;
3597 }
3598 {
3599 wxSize * resultptr;
3600 resultptr = new wxSize((wxSize &)(result));
3601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3602 }
3603 return resultobj;
3604 fail:
3605 return NULL;
3606 }
3607
3608
3609 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3610 PyObject *resultobj;
3611 wxSize *arg1 = (wxSize *) 0 ;
3612 wxSize *arg2 = 0 ;
3613 wxSize result;
3614 wxSize temp2 ;
3615 PyObject * obj0 = 0 ;
3616 PyObject * obj1 = 0 ;
3617 char *kwnames[] = {
3618 (char *) "self",(char *) "sz", NULL
3619 };
3620
3621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3623 if (SWIG_arg_fail(1)) SWIG_fail;
3624 {
3625 arg2 = &temp2;
3626 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3627 }
3628 {
3629 PyThreadState* __tstate = wxPyBeginAllowThreads();
3630 result = (arg1)->operator -((wxSize const &)*arg2);
3631
3632 wxPyEndAllowThreads(__tstate);
3633 if (PyErr_Occurred()) SWIG_fail;
3634 }
3635 {
3636 wxSize * resultptr;
3637 resultptr = new wxSize((wxSize &)(result));
3638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3639 }
3640 return resultobj;
3641 fail:
3642 return NULL;
3643 }
3644
3645
3646 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 wxSize *arg1 = (wxSize *) 0 ;
3649 wxSize *arg2 = 0 ;
3650 wxSize temp2 ;
3651 PyObject * obj0 = 0 ;
3652 PyObject * obj1 = 0 ;
3653 char *kwnames[] = {
3654 (char *) "self",(char *) "sz", NULL
3655 };
3656
3657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3659 if (SWIG_arg_fail(1)) SWIG_fail;
3660 {
3661 arg2 = &temp2;
3662 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3663 }
3664 {
3665 PyThreadState* __tstate = wxPyBeginAllowThreads();
3666 (arg1)->IncTo((wxSize const &)*arg2);
3667
3668 wxPyEndAllowThreads(__tstate);
3669 if (PyErr_Occurred()) SWIG_fail;
3670 }
3671 Py_INCREF(Py_None); resultobj = Py_None;
3672 return resultobj;
3673 fail:
3674 return NULL;
3675 }
3676
3677
3678 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3679 PyObject *resultobj;
3680 wxSize *arg1 = (wxSize *) 0 ;
3681 wxSize *arg2 = 0 ;
3682 wxSize temp2 ;
3683 PyObject * obj0 = 0 ;
3684 PyObject * obj1 = 0 ;
3685 char *kwnames[] = {
3686 (char *) "self",(char *) "sz", NULL
3687 };
3688
3689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3691 if (SWIG_arg_fail(1)) SWIG_fail;
3692 {
3693 arg2 = &temp2;
3694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3695 }
3696 {
3697 PyThreadState* __tstate = wxPyBeginAllowThreads();
3698 (arg1)->DecTo((wxSize const &)*arg2);
3699
3700 wxPyEndAllowThreads(__tstate);
3701 if (PyErr_Occurred()) SWIG_fail;
3702 }
3703 Py_INCREF(Py_None); resultobj = Py_None;
3704 return resultobj;
3705 fail:
3706 return NULL;
3707 }
3708
3709
3710 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3711 PyObject *resultobj;
3712 wxSize *arg1 = (wxSize *) 0 ;
3713 int arg2 ;
3714 int arg3 ;
3715 PyObject * obj0 = 0 ;
3716 PyObject * obj1 = 0 ;
3717 PyObject * obj2 = 0 ;
3718 char *kwnames[] = {
3719 (char *) "self",(char *) "w",(char *) "h", NULL
3720 };
3721
3722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3724 if (SWIG_arg_fail(1)) SWIG_fail;
3725 {
3726 arg2 = (int)(SWIG_As_int(obj1));
3727 if (SWIG_arg_fail(2)) SWIG_fail;
3728 }
3729 {
3730 arg3 = (int)(SWIG_As_int(obj2));
3731 if (SWIG_arg_fail(3)) SWIG_fail;
3732 }
3733 {
3734 PyThreadState* __tstate = wxPyBeginAllowThreads();
3735 (arg1)->Set(arg2,arg3);
3736
3737 wxPyEndAllowThreads(__tstate);
3738 if (PyErr_Occurred()) SWIG_fail;
3739 }
3740 Py_INCREF(Py_None); resultobj = Py_None;
3741 return resultobj;
3742 fail:
3743 return NULL;
3744 }
3745
3746
3747 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3748 PyObject *resultobj;
3749 wxSize *arg1 = (wxSize *) 0 ;
3750 int arg2 ;
3751 PyObject * obj0 = 0 ;
3752 PyObject * obj1 = 0 ;
3753 char *kwnames[] = {
3754 (char *) "self",(char *) "w", NULL
3755 };
3756
3757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3759 if (SWIG_arg_fail(1)) SWIG_fail;
3760 {
3761 arg2 = (int)(SWIG_As_int(obj1));
3762 if (SWIG_arg_fail(2)) SWIG_fail;
3763 }
3764 {
3765 PyThreadState* __tstate = wxPyBeginAllowThreads();
3766 (arg1)->SetWidth(arg2);
3767
3768 wxPyEndAllowThreads(__tstate);
3769 if (PyErr_Occurred()) SWIG_fail;
3770 }
3771 Py_INCREF(Py_None); resultobj = Py_None;
3772 return resultobj;
3773 fail:
3774 return NULL;
3775 }
3776
3777
3778 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3779 PyObject *resultobj;
3780 wxSize *arg1 = (wxSize *) 0 ;
3781 int arg2 ;
3782 PyObject * obj0 = 0 ;
3783 PyObject * obj1 = 0 ;
3784 char *kwnames[] = {
3785 (char *) "self",(char *) "h", NULL
3786 };
3787
3788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3790 if (SWIG_arg_fail(1)) SWIG_fail;
3791 {
3792 arg2 = (int)(SWIG_As_int(obj1));
3793 if (SWIG_arg_fail(2)) SWIG_fail;
3794 }
3795 {
3796 PyThreadState* __tstate = wxPyBeginAllowThreads();
3797 (arg1)->SetHeight(arg2);
3798
3799 wxPyEndAllowThreads(__tstate);
3800 if (PyErr_Occurred()) SWIG_fail;
3801 }
3802 Py_INCREF(Py_None); resultobj = Py_None;
3803 return resultobj;
3804 fail:
3805 return NULL;
3806 }
3807
3808
3809 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3810 PyObject *resultobj;
3811 wxSize *arg1 = (wxSize *) 0 ;
3812 int result;
3813 PyObject * obj0 = 0 ;
3814 char *kwnames[] = {
3815 (char *) "self", NULL
3816 };
3817
3818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3820 if (SWIG_arg_fail(1)) SWIG_fail;
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (int)((wxSize const *)arg1)->GetWidth();
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = SWIG_From_int((int)(result));
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj;
3839 wxSize *arg1 = (wxSize *) 0 ;
3840 int result;
3841 PyObject * obj0 = 0 ;
3842 char *kwnames[] = {
3843 (char *) "self", NULL
3844 };
3845
3846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3848 if (SWIG_arg_fail(1)) SWIG_fail;
3849 {
3850 PyThreadState* __tstate = wxPyBeginAllowThreads();
3851 result = (int)((wxSize const *)arg1)->GetHeight();
3852
3853 wxPyEndAllowThreads(__tstate);
3854 if (PyErr_Occurred()) SWIG_fail;
3855 }
3856 {
3857 resultobj = SWIG_From_int((int)(result));
3858 }
3859 return resultobj;
3860 fail:
3861 return NULL;
3862 }
3863
3864
3865 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3866 PyObject *resultobj;
3867 wxSize *arg1 = (wxSize *) 0 ;
3868 bool result;
3869 PyObject * obj0 = 0 ;
3870 char *kwnames[] = {
3871 (char *) "self", NULL
3872 };
3873
3874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3876 if (SWIG_arg_fail(1)) SWIG_fail;
3877 {
3878 PyThreadState* __tstate = wxPyBeginAllowThreads();
3879 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3880
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 {
3885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3886 }
3887 return resultobj;
3888 fail:
3889 return NULL;
3890 }
3891
3892
3893 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3894 PyObject *resultobj;
3895 wxSize *arg1 = (wxSize *) 0 ;
3896 wxSize *arg2 = 0 ;
3897 wxSize temp2 ;
3898 PyObject * obj0 = 0 ;
3899 PyObject * obj1 = 0 ;
3900 char *kwnames[] = {
3901 (char *) "self",(char *) "size", NULL
3902 };
3903
3904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3906 if (SWIG_arg_fail(1)) SWIG_fail;
3907 {
3908 arg2 = &temp2;
3909 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3910 }
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 (arg1)->SetDefaults((wxSize const &)*arg2);
3914
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 Py_INCREF(Py_None); resultobj = Py_None;
3919 return resultobj;
3920 fail:
3921 return NULL;
3922 }
3923
3924
3925 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3926 PyObject *resultobj;
3927 wxSize *arg1 = (wxSize *) 0 ;
3928 PyObject *result;
3929 PyObject * obj0 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "self", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3936 if (SWIG_arg_fail(1)) SWIG_fail;
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 result = (PyObject *)wxSize_Get(arg1);
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 resultobj = result;
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3952 PyObject *obj;
3953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3954 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3955 Py_INCREF(obj);
3956 return Py_BuildValue((char *)"");
3957 }
3958 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3959 PyObject *resultobj;
3960 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3961 double arg2 ;
3962 PyObject * obj0 = 0 ;
3963 PyObject * obj1 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self",(char *) "x", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 {
3972 arg2 = (double)(SWIG_As_double(obj1));
3973 if (SWIG_arg_fail(2)) SWIG_fail;
3974 }
3975 if (arg1) (arg1)->x = arg2;
3976
3977 Py_INCREF(Py_None); resultobj = Py_None;
3978 return resultobj;
3979 fail:
3980 return NULL;
3981 }
3982
3983
3984 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3985 PyObject *resultobj;
3986 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3987 double result;
3988 PyObject * obj0 = 0 ;
3989 char *kwnames[] = {
3990 (char *) "self", NULL
3991 };
3992
3993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3995 if (SWIG_arg_fail(1)) SWIG_fail;
3996 result = (double) ((arg1)->x);
3997
3998 {
3999 resultobj = SWIG_From_double((double)(result));
4000 }
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj;
4009 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4010 double arg2 ;
4011 PyObject * obj0 = 0 ;
4012 PyObject * obj1 = 0 ;
4013 char *kwnames[] = {
4014 (char *) "self",(char *) "y", NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 {
4021 arg2 = (double)(SWIG_As_double(obj1));
4022 if (SWIG_arg_fail(2)) SWIG_fail;
4023 }
4024 if (arg1) (arg1)->y = arg2;
4025
4026 Py_INCREF(Py_None); resultobj = Py_None;
4027 return resultobj;
4028 fail:
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4036 double result;
4037 PyObject * obj0 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "self", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4044 if (SWIG_arg_fail(1)) SWIG_fail;
4045 result = (double) ((arg1)->y);
4046
4047 {
4048 resultobj = SWIG_From_double((double)(result));
4049 }
4050 return resultobj;
4051 fail:
4052 return NULL;
4053 }
4054
4055
4056 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4057 PyObject *resultobj;
4058 double arg1 = (double) 0.0 ;
4059 double arg2 = (double) 0.0 ;
4060 wxRealPoint *result;
4061 PyObject * obj0 = 0 ;
4062 PyObject * obj1 = 0 ;
4063 char *kwnames[] = {
4064 (char *) "x",(char *) "y", NULL
4065 };
4066
4067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4068 if (obj0) {
4069 {
4070 arg1 = (double)(SWIG_As_double(obj0));
4071 if (SWIG_arg_fail(1)) SWIG_fail;
4072 }
4073 }
4074 if (obj1) {
4075 {
4076 arg2 = (double)(SWIG_As_double(obj1));
4077 if (SWIG_arg_fail(2)) SWIG_fail;
4078 }
4079 }
4080 {
4081 PyThreadState* __tstate = wxPyBeginAllowThreads();
4082 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4083
4084 wxPyEndAllowThreads(__tstate);
4085 if (PyErr_Occurred()) SWIG_fail;
4086 }
4087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4088 return resultobj;
4089 fail:
4090 return NULL;
4091 }
4092
4093
4094 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj;
4096 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4097 PyObject * obj0 = 0 ;
4098 char *kwnames[] = {
4099 (char *) "self", NULL
4100 };
4101
4102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4104 if (SWIG_arg_fail(1)) SWIG_fail;
4105 {
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 delete arg1;
4108
4109 wxPyEndAllowThreads(__tstate);
4110 if (PyErr_Occurred()) SWIG_fail;
4111 }
4112 Py_INCREF(Py_None); resultobj = Py_None;
4113 return resultobj;
4114 fail:
4115 return NULL;
4116 }
4117
4118
4119 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4120 PyObject *resultobj;
4121 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4122 wxRealPoint *arg2 = 0 ;
4123 bool result;
4124 wxRealPoint temp2 ;
4125 PyObject * obj0 = 0 ;
4126 PyObject * obj1 = 0 ;
4127 char *kwnames[] = {
4128 (char *) "self",(char *) "pt", NULL
4129 };
4130
4131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4133 if (SWIG_arg_fail(1)) SWIG_fail;
4134 {
4135 arg2 = &temp2;
4136 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4137 }
4138 {
4139 PyThreadState* __tstate = wxPyBeginAllowThreads();
4140 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4141
4142 wxPyEndAllowThreads(__tstate);
4143 if (PyErr_Occurred()) SWIG_fail;
4144 }
4145 {
4146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4147 }
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj;
4156 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4157 wxRealPoint *arg2 = 0 ;
4158 bool result;
4159 wxRealPoint temp2 ;
4160 PyObject * obj0 = 0 ;
4161 PyObject * obj1 = 0 ;
4162 char *kwnames[] = {
4163 (char *) "self",(char *) "pt", NULL
4164 };
4165
4166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4168 if (SWIG_arg_fail(1)) SWIG_fail;
4169 {
4170 arg2 = &temp2;
4171 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4172 }
4173 {
4174 PyThreadState* __tstate = wxPyBeginAllowThreads();
4175 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4176
4177 wxPyEndAllowThreads(__tstate);
4178 if (PyErr_Occurred()) SWIG_fail;
4179 }
4180 {
4181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4182 }
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj;
4191 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4192 wxRealPoint *arg2 = 0 ;
4193 wxRealPoint result;
4194 wxRealPoint temp2 ;
4195 PyObject * obj0 = 0 ;
4196 PyObject * obj1 = 0 ;
4197 char *kwnames[] = {
4198 (char *) "self",(char *) "pt", NULL
4199 };
4200
4201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4203 if (SWIG_arg_fail(1)) SWIG_fail;
4204 {
4205 arg2 = &temp2;
4206 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4207 }
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 wxRealPoint * resultptr;
4217 resultptr = new wxRealPoint((wxRealPoint &)(result));
4218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4219 }
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj;
4228 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4229 wxRealPoint *arg2 = 0 ;
4230 wxRealPoint result;
4231 wxRealPoint temp2 ;
4232 PyObject * obj0 = 0 ;
4233 PyObject * obj1 = 0 ;
4234 char *kwnames[] = {
4235 (char *) "self",(char *) "pt", NULL
4236 };
4237
4238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4240 if (SWIG_arg_fail(1)) SWIG_fail;
4241 {
4242 arg2 = &temp2;
4243 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4244 }
4245 {
4246 PyThreadState* __tstate = wxPyBeginAllowThreads();
4247 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4248
4249 wxPyEndAllowThreads(__tstate);
4250 if (PyErr_Occurred()) SWIG_fail;
4251 }
4252 {
4253 wxRealPoint * resultptr;
4254 resultptr = new wxRealPoint((wxRealPoint &)(result));
4255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4256 }
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4264 PyObject *resultobj;
4265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4266 double arg2 ;
4267 double arg3 ;
4268 PyObject * obj0 = 0 ;
4269 PyObject * obj1 = 0 ;
4270 PyObject * obj2 = 0 ;
4271 char *kwnames[] = {
4272 (char *) "self",(char *) "x",(char *) "y", NULL
4273 };
4274
4275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4277 if (SWIG_arg_fail(1)) SWIG_fail;
4278 {
4279 arg2 = (double)(SWIG_As_double(obj1));
4280 if (SWIG_arg_fail(2)) SWIG_fail;
4281 }
4282 {
4283 arg3 = (double)(SWIG_As_double(obj2));
4284 if (SWIG_arg_fail(3)) SWIG_fail;
4285 }
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 wxRealPoint_Set(arg1,arg2,arg3);
4289
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 Py_INCREF(Py_None); resultobj = Py_None;
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj;
4302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4303 PyObject *result;
4304 PyObject * obj0 = 0 ;
4305 char *kwnames[] = {
4306 (char *) "self", NULL
4307 };
4308
4309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4311 if (SWIG_arg_fail(1)) SWIG_fail;
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (PyObject *)wxRealPoint_Get(arg1);
4315
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = result;
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4327 PyObject *obj;
4328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4329 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4330 Py_INCREF(obj);
4331 return Py_BuildValue((char *)"");
4332 }
4333 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4334 PyObject *resultobj;
4335 wxPoint *arg1 = (wxPoint *) 0 ;
4336 int arg2 ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 char *kwnames[] = {
4340 (char *) "self",(char *) "x", NULL
4341 };
4342
4343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4345 if (SWIG_arg_fail(1)) SWIG_fail;
4346 {
4347 arg2 = (int)(SWIG_As_int(obj1));
4348 if (SWIG_arg_fail(2)) SWIG_fail;
4349 }
4350 if (arg1) (arg1)->x = arg2;
4351
4352 Py_INCREF(Py_None); resultobj = Py_None;
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj;
4361 wxPoint *arg1 = (wxPoint *) 0 ;
4362 int result;
4363 PyObject * obj0 = 0 ;
4364 char *kwnames[] = {
4365 (char *) "self", NULL
4366 };
4367
4368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4370 if (SWIG_arg_fail(1)) SWIG_fail;
4371 result = (int) ((arg1)->x);
4372
4373 {
4374 resultobj = SWIG_From_int((int)(result));
4375 }
4376 return resultobj;
4377 fail:
4378 return NULL;
4379 }
4380
4381
4382 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj;
4384 wxPoint *arg1 = (wxPoint *) 0 ;
4385 int arg2 ;
4386 PyObject * obj0 = 0 ;
4387 PyObject * obj1 = 0 ;
4388 char *kwnames[] = {
4389 (char *) "self",(char *) "y", NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 {
4396 arg2 = (int)(SWIG_As_int(obj1));
4397 if (SWIG_arg_fail(2)) SWIG_fail;
4398 }
4399 if (arg1) (arg1)->y = arg2;
4400
4401 Py_INCREF(Py_None); resultobj = Py_None;
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj;
4410 wxPoint *arg1 = (wxPoint *) 0 ;
4411 int result;
4412 PyObject * obj0 = 0 ;
4413 char *kwnames[] = {
4414 (char *) "self", NULL
4415 };
4416
4417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4419 if (SWIG_arg_fail(1)) SWIG_fail;
4420 result = (int) ((arg1)->y);
4421
4422 {
4423 resultobj = SWIG_From_int((int)(result));
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4432 PyObject *resultobj;
4433 int arg1 = (int) 0 ;
4434 int arg2 = (int) 0 ;
4435 wxPoint *result;
4436 PyObject * obj0 = 0 ;
4437 PyObject * obj1 = 0 ;
4438 char *kwnames[] = {
4439 (char *) "x",(char *) "y", NULL
4440 };
4441
4442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4443 if (obj0) {
4444 {
4445 arg1 = (int)(SWIG_As_int(obj0));
4446 if (SWIG_arg_fail(1)) SWIG_fail;
4447 }
4448 }
4449 if (obj1) {
4450 {
4451 arg2 = (int)(SWIG_As_int(obj1));
4452 if (SWIG_arg_fail(2)) SWIG_fail;
4453 }
4454 }
4455 {
4456 PyThreadState* __tstate = wxPyBeginAllowThreads();
4457 result = (wxPoint *)new wxPoint(arg1,arg2);
4458
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4463 return resultobj;
4464 fail:
4465 return NULL;
4466 }
4467
4468
4469 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4470 PyObject *resultobj;
4471 wxPoint *arg1 = (wxPoint *) 0 ;
4472 PyObject * obj0 = 0 ;
4473 char *kwnames[] = {
4474 (char *) "self", NULL
4475 };
4476
4477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4479 if (SWIG_arg_fail(1)) SWIG_fail;
4480 {
4481 PyThreadState* __tstate = wxPyBeginAllowThreads();
4482 delete arg1;
4483
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 Py_INCREF(Py_None); resultobj = Py_None;
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj;
4496 wxPoint *arg1 = (wxPoint *) 0 ;
4497 wxPoint *arg2 = 0 ;
4498 bool result;
4499 wxPoint temp2 ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 char *kwnames[] = {
4503 (char *) "self",(char *) "pt", NULL
4504 };
4505
4506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4508 if (SWIG_arg_fail(1)) SWIG_fail;
4509 {
4510 arg2 = &temp2;
4511 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4512 }
4513 {
4514 PyThreadState* __tstate = wxPyBeginAllowThreads();
4515 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4516
4517 wxPyEndAllowThreads(__tstate);
4518 if (PyErr_Occurred()) SWIG_fail;
4519 }
4520 {
4521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4522 }
4523 return resultobj;
4524 fail:
4525 return NULL;
4526 }
4527
4528
4529 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4530 PyObject *resultobj;
4531 wxPoint *arg1 = (wxPoint *) 0 ;
4532 wxPoint *arg2 = 0 ;
4533 bool result;
4534 wxPoint temp2 ;
4535 PyObject * obj0 = 0 ;
4536 PyObject * obj1 = 0 ;
4537 char *kwnames[] = {
4538 (char *) "self",(char *) "pt", NULL
4539 };
4540
4541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4543 if (SWIG_arg_fail(1)) SWIG_fail;
4544 {
4545 arg2 = &temp2;
4546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4547 }
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4551
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 {
4556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4557 }
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4565 PyObject *resultobj;
4566 wxPoint *arg1 = (wxPoint *) 0 ;
4567 wxPoint *arg2 = 0 ;
4568 wxPoint result;
4569 wxPoint temp2 ;
4570 PyObject * obj0 = 0 ;
4571 PyObject * obj1 = 0 ;
4572 char *kwnames[] = {
4573 (char *) "self",(char *) "pt", NULL
4574 };
4575
4576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4578 if (SWIG_arg_fail(1)) SWIG_fail;
4579 {
4580 arg2 = &temp2;
4581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4582 }
4583 {
4584 PyThreadState* __tstate = wxPyBeginAllowThreads();
4585 result = (arg1)->operator +((wxPoint const &)*arg2);
4586
4587 wxPyEndAllowThreads(__tstate);
4588 if (PyErr_Occurred()) SWIG_fail;
4589 }
4590 {
4591 wxPoint * resultptr;
4592 resultptr = new wxPoint((wxPoint &)(result));
4593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4594 }
4595 return resultobj;
4596 fail:
4597 return NULL;
4598 }
4599
4600
4601 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4602 PyObject *resultobj;
4603 wxPoint *arg1 = (wxPoint *) 0 ;
4604 wxPoint *arg2 = 0 ;
4605 wxPoint result;
4606 wxPoint temp2 ;
4607 PyObject * obj0 = 0 ;
4608 PyObject * obj1 = 0 ;
4609 char *kwnames[] = {
4610 (char *) "self",(char *) "pt", NULL
4611 };
4612
4613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4615 if (SWIG_arg_fail(1)) SWIG_fail;
4616 {
4617 arg2 = &temp2;
4618 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4619 }
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 result = (arg1)->operator -((wxPoint const &)*arg2);
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 {
4628 wxPoint * resultptr;
4629 resultptr = new wxPoint((wxPoint &)(result));
4630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4631 }
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj;
4640 wxPoint *arg1 = (wxPoint *) 0 ;
4641 wxPoint *arg2 = 0 ;
4642 wxPoint *result;
4643 wxPoint temp2 ;
4644 PyObject * obj0 = 0 ;
4645 PyObject * obj1 = 0 ;
4646 char *kwnames[] = {
4647 (char *) "self",(char *) "pt", NULL
4648 };
4649
4650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4652 if (SWIG_arg_fail(1)) SWIG_fail;
4653 {
4654 arg2 = &temp2;
4655 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4656 }
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 {
4660 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4661 result = (wxPoint *) &_result_ref;
4662 }
4663
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj;
4676 wxPoint *arg1 = (wxPoint *) 0 ;
4677 wxPoint *arg2 = 0 ;
4678 wxPoint *result;
4679 wxPoint temp2 ;
4680 PyObject * obj0 = 0 ;
4681 PyObject * obj1 = 0 ;
4682 char *kwnames[] = {
4683 (char *) "self",(char *) "pt", NULL
4684 };
4685
4686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4688 if (SWIG_arg_fail(1)) SWIG_fail;
4689 {
4690 arg2 = &temp2;
4691 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4692 }
4693 {
4694 PyThreadState* __tstate = wxPyBeginAllowThreads();
4695 {
4696 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4697 result = (wxPoint *) &_result_ref;
4698 }
4699
4700 wxPyEndAllowThreads(__tstate);
4701 if (PyErr_Occurred()) SWIG_fail;
4702 }
4703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4711 PyObject *resultobj;
4712 wxPoint *arg1 = (wxPoint *) 0 ;
4713 long arg2 ;
4714 long arg3 ;
4715 PyObject * obj0 = 0 ;
4716 PyObject * obj1 = 0 ;
4717 PyObject * obj2 = 0 ;
4718 char *kwnames[] = {
4719 (char *) "self",(char *) "x",(char *) "y", NULL
4720 };
4721
4722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4724 if (SWIG_arg_fail(1)) SWIG_fail;
4725 {
4726 arg2 = (long)(SWIG_As_long(obj1));
4727 if (SWIG_arg_fail(2)) SWIG_fail;
4728 }
4729 {
4730 arg3 = (long)(SWIG_As_long(obj2));
4731 if (SWIG_arg_fail(3)) SWIG_fail;
4732 }
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 wxPoint_Set(arg1,arg2,arg3);
4736
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 Py_INCREF(Py_None); resultobj = Py_None;
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj;
4749 wxPoint *arg1 = (wxPoint *) 0 ;
4750 PyObject *result;
4751 PyObject * obj0 = 0 ;
4752 char *kwnames[] = {
4753 (char *) "self", NULL
4754 };
4755
4756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4758 if (SWIG_arg_fail(1)) SWIG_fail;
4759 {
4760 PyThreadState* __tstate = wxPyBeginAllowThreads();
4761 result = (PyObject *)wxPoint_Get(arg1);
4762
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 resultobj = result;
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4774 PyObject *obj;
4775 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4776 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4777 Py_INCREF(obj);
4778 return Py_BuildValue((char *)"");
4779 }
4780 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4781 PyObject *resultobj;
4782 int arg1 = (int) 0 ;
4783 int arg2 = (int) 0 ;
4784 int arg3 = (int) 0 ;
4785 int arg4 = (int) 0 ;
4786 wxRect *result;
4787 PyObject * obj0 = 0 ;
4788 PyObject * obj1 = 0 ;
4789 PyObject * obj2 = 0 ;
4790 PyObject * obj3 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4796 if (obj0) {
4797 {
4798 arg1 = (int)(SWIG_As_int(obj0));
4799 if (SWIG_arg_fail(1)) SWIG_fail;
4800 }
4801 }
4802 if (obj1) {
4803 {
4804 arg2 = (int)(SWIG_As_int(obj1));
4805 if (SWIG_arg_fail(2)) SWIG_fail;
4806 }
4807 }
4808 if (obj2) {
4809 {
4810 arg3 = (int)(SWIG_As_int(obj2));
4811 if (SWIG_arg_fail(3)) SWIG_fail;
4812 }
4813 }
4814 if (obj3) {
4815 {
4816 arg4 = (int)(SWIG_As_int(obj3));
4817 if (SWIG_arg_fail(4)) SWIG_fail;
4818 }
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4823
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj;
4836 wxPoint *arg1 = 0 ;
4837 wxPoint *arg2 = 0 ;
4838 wxRect *result;
4839 wxPoint temp1 ;
4840 wxPoint temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char *kwnames[] = {
4844 (char *) "topLeft",(char *) "bottomRight", NULL
4845 };
4846
4847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4848 {
4849 arg1 = &temp1;
4850 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4851 }
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4859
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj;
4872 wxPoint *arg1 = 0 ;
4873 wxSize *arg2 = 0 ;
4874 wxRect *result;
4875 wxPoint temp1 ;
4876 wxSize temp2 ;
4877 PyObject * obj0 = 0 ;
4878 PyObject * obj1 = 0 ;
4879 char *kwnames[] = {
4880 (char *) "pos",(char *) "size", NULL
4881 };
4882
4883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4884 {
4885 arg1 = &temp1;
4886 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4887 }
4888 {
4889 arg2 = &temp2;
4890 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4891 }
4892 {
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4895
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4907 PyObject *resultobj;
4908 wxSize *arg1 = 0 ;
4909 wxRect *result;
4910 wxSize temp1 ;
4911 PyObject * obj0 = 0 ;
4912 char *kwnames[] = {
4913 (char *) "size", NULL
4914 };
4915
4916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4917 {
4918 arg1 = &temp1;
4919 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4920 }
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4924
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4929 return resultobj;
4930 fail:
4931 return NULL;
4932 }
4933
4934
4935 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4936 PyObject *resultobj;
4937 wxRect *arg1 = (wxRect *) 0 ;
4938 PyObject * obj0 = 0 ;
4939 char *kwnames[] = {
4940 (char *) "self", NULL
4941 };
4942
4943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4945 if (SWIG_arg_fail(1)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 delete arg1;
4949
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 Py_INCREF(Py_None); resultobj = Py_None;
4954 return resultobj;
4955 fail:
4956 return NULL;
4957 }
4958
4959
4960 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4961 PyObject *resultobj;
4962 wxRect *arg1 = (wxRect *) 0 ;
4963 int result;
4964 PyObject * obj0 = 0 ;
4965 char *kwnames[] = {
4966 (char *) "self", NULL
4967 };
4968
4969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4971 if (SWIG_arg_fail(1)) SWIG_fail;
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (int)((wxRect const *)arg1)->GetX();
4975
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 {
4980 resultobj = SWIG_From_int((int)(result));
4981 }
4982 return resultobj;
4983 fail:
4984 return NULL;
4985 }
4986
4987
4988 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj;
4990 wxRect *arg1 = (wxRect *) 0 ;
4991 int arg2 ;
4992 PyObject * obj0 = 0 ;
4993 PyObject * obj1 = 0 ;
4994 char *kwnames[] = {
4995 (char *) "self",(char *) "x", NULL
4996 };
4997
4998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5000 if (SWIG_arg_fail(1)) SWIG_fail;
5001 {
5002 arg2 = (int)(SWIG_As_int(obj1));
5003 if (SWIG_arg_fail(2)) SWIG_fail;
5004 }
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 (arg1)->SetX(arg2);
5008
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 Py_INCREF(Py_None); resultobj = Py_None;
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj;
5021 wxRect *arg1 = (wxRect *) 0 ;
5022 int result;
5023 PyObject * obj0 = 0 ;
5024 char *kwnames[] = {
5025 (char *) "self", NULL
5026 };
5027
5028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5030 if (SWIG_arg_fail(1)) SWIG_fail;
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 result = (int)(arg1)->GetY();
5034
5035 wxPyEndAllowThreads(__tstate);
5036 if (PyErr_Occurred()) SWIG_fail;
5037 }
5038 {
5039 resultobj = SWIG_From_int((int)(result));
5040 }
5041 return resultobj;
5042 fail:
5043 return NULL;
5044 }
5045
5046
5047 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5048 PyObject *resultobj;
5049 wxRect *arg1 = (wxRect *) 0 ;
5050 int arg2 ;
5051 PyObject * obj0 = 0 ;
5052 PyObject * obj1 = 0 ;
5053 char *kwnames[] = {
5054 (char *) "self",(char *) "y", NULL
5055 };
5056
5057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5059 if (SWIG_arg_fail(1)) SWIG_fail;
5060 {
5061 arg2 = (int)(SWIG_As_int(obj1));
5062 if (SWIG_arg_fail(2)) SWIG_fail;
5063 }
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 (arg1)->SetY(arg2);
5067
5068 wxPyEndAllowThreads(__tstate);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 Py_INCREF(Py_None); resultobj = Py_None;
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5079 PyObject *resultobj;
5080 wxRect *arg1 = (wxRect *) 0 ;
5081 int result;
5082 PyObject * obj0 = 0 ;
5083 char *kwnames[] = {
5084 (char *) "self", NULL
5085 };
5086
5087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5089 if (SWIG_arg_fail(1)) SWIG_fail;
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = (int)((wxRect const *)arg1)->GetWidth();
5093
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = SWIG_From_int((int)(result));
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj;
5108 wxRect *arg1 = (wxRect *) 0 ;
5109 int arg2 ;
5110 PyObject * obj0 = 0 ;
5111 PyObject * obj1 = 0 ;
5112 char *kwnames[] = {
5113 (char *) "self",(char *) "w", NULL
5114 };
5115
5116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5118 if (SWIG_arg_fail(1)) SWIG_fail;
5119 {
5120 arg2 = (int)(SWIG_As_int(obj1));
5121 if (SWIG_arg_fail(2)) SWIG_fail;
5122 }
5123 {
5124 PyThreadState* __tstate = wxPyBeginAllowThreads();
5125 (arg1)->SetWidth(arg2);
5126
5127 wxPyEndAllowThreads(__tstate);
5128 if (PyErr_Occurred()) SWIG_fail;
5129 }
5130 Py_INCREF(Py_None); resultobj = Py_None;
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5138 PyObject *resultobj;
5139 wxRect *arg1 = (wxRect *) 0 ;
5140 int result;
5141 PyObject * obj0 = 0 ;
5142 char *kwnames[] = {
5143 (char *) "self", NULL
5144 };
5145
5146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5148 if (SWIG_arg_fail(1)) SWIG_fail;
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 result = (int)((wxRect const *)arg1)->GetHeight();
5152
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 {
5157 resultobj = SWIG_From_int((int)(result));
5158 }
5159 return resultobj;
5160 fail:
5161 return NULL;
5162 }
5163
5164
5165 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5166 PyObject *resultobj;
5167 wxRect *arg1 = (wxRect *) 0 ;
5168 int arg2 ;
5169 PyObject * obj0 = 0 ;
5170 PyObject * obj1 = 0 ;
5171 char *kwnames[] = {
5172 (char *) "self",(char *) "h", NULL
5173 };
5174
5175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5177 if (SWIG_arg_fail(1)) SWIG_fail;
5178 {
5179 arg2 = (int)(SWIG_As_int(obj1));
5180 if (SWIG_arg_fail(2)) SWIG_fail;
5181 }
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 (arg1)->SetHeight(arg2);
5185
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 Py_INCREF(Py_None); resultobj = Py_None;
5190 return resultobj;
5191 fail:
5192 return NULL;
5193 }
5194
5195
5196 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj;
5198 wxRect *arg1 = (wxRect *) 0 ;
5199 wxPoint result;
5200 PyObject * obj0 = 0 ;
5201 char *kwnames[] = {
5202 (char *) "self", NULL
5203 };
5204
5205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5207 if (SWIG_arg_fail(1)) SWIG_fail;
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 result = ((wxRect const *)arg1)->GetPosition();
5211
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 {
5216 wxPoint * resultptr;
5217 resultptr = new wxPoint((wxPoint &)(result));
5218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5219 }
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj;
5228 wxRect *arg1 = (wxRect *) 0 ;
5229 wxPoint *arg2 = 0 ;
5230 wxPoint temp2 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5233 char *kwnames[] = {
5234 (char *) "self",(char *) "p", NULL
5235 };
5236
5237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5239 if (SWIG_arg_fail(1)) SWIG_fail;
5240 {
5241 arg2 = &temp2;
5242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5243 }
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 (arg1)->SetPosition((wxPoint const &)*arg2);
5247
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 Py_INCREF(Py_None); resultobj = Py_None;
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj;
5260 wxRect *arg1 = (wxRect *) 0 ;
5261 wxSize result;
5262 PyObject * obj0 = 0 ;
5263 char *kwnames[] = {
5264 (char *) "self", NULL
5265 };
5266
5267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5269 if (SWIG_arg_fail(1)) SWIG_fail;
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = ((wxRect const *)arg1)->GetSize();
5273
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 {
5278 wxSize * resultptr;
5279 resultptr = new wxSize((wxSize &)(result));
5280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5281 }
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5289 PyObject *resultobj;
5290 wxRect *arg1 = (wxRect *) 0 ;
5291 wxSize *arg2 = 0 ;
5292 wxSize temp2 ;
5293 PyObject * obj0 = 0 ;
5294 PyObject * obj1 = 0 ;
5295 char *kwnames[] = {
5296 (char *) "self",(char *) "s", NULL
5297 };
5298
5299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5301 if (SWIG_arg_fail(1)) SWIG_fail;
5302 {
5303 arg2 = &temp2;
5304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5305 }
5306 {
5307 PyThreadState* __tstate = wxPyBeginAllowThreads();
5308 (arg1)->SetSize((wxSize const &)*arg2);
5309
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 Py_INCREF(Py_None); resultobj = Py_None;
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj;
5322 wxRect *arg1 = (wxRect *) 0 ;
5323 bool result;
5324 PyObject * obj0 = 0 ;
5325 char *kwnames[] = {
5326 (char *) "self", NULL
5327 };
5328
5329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5331 if (SWIG_arg_fail(1)) SWIG_fail;
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 result = (bool)((wxRect const *)arg1)->IsEmpty();
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 {
5340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5341 }
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5349 PyObject *resultobj;
5350 wxRect *arg1 = (wxRect *) 0 ;
5351 wxPoint result;
5352 PyObject * obj0 = 0 ;
5353 char *kwnames[] = {
5354 (char *) "self", NULL
5355 };
5356
5357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5359 if (SWIG_arg_fail(1)) SWIG_fail;
5360 {
5361 PyThreadState* __tstate = wxPyBeginAllowThreads();
5362 result = ((wxRect const *)arg1)->GetTopLeft();
5363
5364 wxPyEndAllowThreads(__tstate);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 wxPoint * resultptr;
5369 resultptr = new wxPoint((wxPoint &)(result));
5370 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5371 }
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj;
5380 wxRect *arg1 = (wxRect *) 0 ;
5381 wxPoint *arg2 = 0 ;
5382 wxPoint temp2 ;
5383 PyObject * obj0 = 0 ;
5384 PyObject * obj1 = 0 ;
5385 char *kwnames[] = {
5386 (char *) "self",(char *) "p", NULL
5387 };
5388
5389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5391 if (SWIG_arg_fail(1)) SWIG_fail;
5392 {
5393 arg2 = &temp2;
5394 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5395 }
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5399
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 Py_INCREF(Py_None); resultobj = Py_None;
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj;
5412 wxRect *arg1 = (wxRect *) 0 ;
5413 wxPoint result;
5414 PyObject * obj0 = 0 ;
5415 char *kwnames[] = {
5416 (char *) "self", NULL
5417 };
5418
5419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5421 if (SWIG_arg_fail(1)) SWIG_fail;
5422 {
5423 PyThreadState* __tstate = wxPyBeginAllowThreads();
5424 result = ((wxRect const *)arg1)->GetBottomRight();
5425
5426 wxPyEndAllowThreads(__tstate);
5427 if (PyErr_Occurred()) SWIG_fail;
5428 }
5429 {
5430 wxPoint * resultptr;
5431 resultptr = new wxPoint((wxPoint &)(result));
5432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj;
5442 wxRect *arg1 = (wxRect *) 0 ;
5443 wxPoint *arg2 = 0 ;
5444 wxPoint temp2 ;
5445 PyObject * obj0 = 0 ;
5446 PyObject * obj1 = 0 ;
5447 char *kwnames[] = {
5448 (char *) "self",(char *) "p", NULL
5449 };
5450
5451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5453 if (SWIG_arg_fail(1)) SWIG_fail;
5454 {
5455 arg2 = &temp2;
5456 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5457 }
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5461
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 Py_INCREF(Py_None); resultobj = Py_None;
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj;
5474 wxRect *arg1 = (wxRect *) 0 ;
5475 int result;
5476 PyObject * obj0 = 0 ;
5477 char *kwnames[] = {
5478 (char *) "self", NULL
5479 };
5480
5481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5483 if (SWIG_arg_fail(1)) SWIG_fail;
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (int)((wxRect const *)arg1)->GetLeft();
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 resultobj = SWIG_From_int((int)(result));
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5501 PyObject *resultobj;
5502 wxRect *arg1 = (wxRect *) 0 ;
5503 int result;
5504 PyObject * obj0 = 0 ;
5505 char *kwnames[] = {
5506 (char *) "self", NULL
5507 };
5508
5509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5511 if (SWIG_arg_fail(1)) SWIG_fail;
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = (int)((wxRect const *)arg1)->GetTop();
5515
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 {
5520 resultobj = SWIG_From_int((int)(result));
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj;
5530 wxRect *arg1 = (wxRect *) 0 ;
5531 int result;
5532 PyObject * obj0 = 0 ;
5533 char *kwnames[] = {
5534 (char *) "self", NULL
5535 };
5536
5537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5539 if (SWIG_arg_fail(1)) SWIG_fail;
5540 {
5541 PyThreadState* __tstate = wxPyBeginAllowThreads();
5542 result = (int)((wxRect const *)arg1)->GetBottom();
5543
5544 wxPyEndAllowThreads(__tstate);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 {
5548 resultobj = SWIG_From_int((int)(result));
5549 }
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5557 PyObject *resultobj;
5558 wxRect *arg1 = (wxRect *) 0 ;
5559 int result;
5560 PyObject * obj0 = 0 ;
5561 char *kwnames[] = {
5562 (char *) "self", NULL
5563 };
5564
5565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5567 if (SWIG_arg_fail(1)) SWIG_fail;
5568 {
5569 PyThreadState* __tstate = wxPyBeginAllowThreads();
5570 result = (int)((wxRect const *)arg1)->GetRight();
5571
5572 wxPyEndAllowThreads(__tstate);
5573 if (PyErr_Occurred()) SWIG_fail;
5574 }
5575 {
5576 resultobj = SWIG_From_int((int)(result));
5577 }
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj;
5586 wxRect *arg1 = (wxRect *) 0 ;
5587 int arg2 ;
5588 PyObject * obj0 = 0 ;
5589 PyObject * obj1 = 0 ;
5590 char *kwnames[] = {
5591 (char *) "self",(char *) "left", NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5596 if (SWIG_arg_fail(1)) SWIG_fail;
5597 {
5598 arg2 = (int)(SWIG_As_int(obj1));
5599 if (SWIG_arg_fail(2)) SWIG_fail;
5600 }
5601 {
5602 PyThreadState* __tstate = wxPyBeginAllowThreads();
5603 (arg1)->SetLeft(arg2);
5604
5605 wxPyEndAllowThreads(__tstate);
5606 if (PyErr_Occurred()) SWIG_fail;
5607 }
5608 Py_INCREF(Py_None); resultobj = Py_None;
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5616 PyObject *resultobj;
5617 wxRect *arg1 = (wxRect *) 0 ;
5618 int arg2 ;
5619 PyObject * obj0 = 0 ;
5620 PyObject * obj1 = 0 ;
5621 char *kwnames[] = {
5622 (char *) "self",(char *) "right", NULL
5623 };
5624
5625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5627 if (SWIG_arg_fail(1)) SWIG_fail;
5628 {
5629 arg2 = (int)(SWIG_As_int(obj1));
5630 if (SWIG_arg_fail(2)) SWIG_fail;
5631 }
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 (arg1)->SetRight(arg2);
5635
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 Py_INCREF(Py_None); resultobj = Py_None;
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj;
5648 wxRect *arg1 = (wxRect *) 0 ;
5649 int arg2 ;
5650 PyObject * obj0 = 0 ;
5651 PyObject * obj1 = 0 ;
5652 char *kwnames[] = {
5653 (char *) "self",(char *) "top", NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5658 if (SWIG_arg_fail(1)) SWIG_fail;
5659 {
5660 arg2 = (int)(SWIG_As_int(obj1));
5661 if (SWIG_arg_fail(2)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 (arg1)->SetTop(arg2);
5666
5667 wxPyEndAllowThreads(__tstate);
5668 if (PyErr_Occurred()) SWIG_fail;
5669 }
5670 Py_INCREF(Py_None); resultobj = Py_None;
5671 return resultobj;
5672 fail:
5673 return NULL;
5674 }
5675
5676
5677 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5678 PyObject *resultobj;
5679 wxRect *arg1 = (wxRect *) 0 ;
5680 int arg2 ;
5681 PyObject * obj0 = 0 ;
5682 PyObject * obj1 = 0 ;
5683 char *kwnames[] = {
5684 (char *) "self",(char *) "bottom", NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 {
5691 arg2 = (int)(SWIG_As_int(obj1));
5692 if (SWIG_arg_fail(2)) SWIG_fail;
5693 }
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 (arg1)->SetBottom(arg2);
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 Py_INCREF(Py_None); resultobj = Py_None;
5702 return resultobj;
5703 fail:
5704 return NULL;
5705 }
5706
5707
5708 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5709 PyObject *resultobj;
5710 wxRect *arg1 = (wxRect *) 0 ;
5711 int arg2 ;
5712 int arg3 ;
5713 wxRect *result;
5714 PyObject * obj0 = 0 ;
5715 PyObject * obj1 = 0 ;
5716 PyObject * obj2 = 0 ;
5717 char *kwnames[] = {
5718 (char *) "self",(char *) "dx",(char *) "dy", NULL
5719 };
5720
5721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5723 if (SWIG_arg_fail(1)) SWIG_fail;
5724 {
5725 arg2 = (int)(SWIG_As_int(obj1));
5726 if (SWIG_arg_fail(2)) SWIG_fail;
5727 }
5728 {
5729 arg3 = (int)(SWIG_As_int(obj2));
5730 if (SWIG_arg_fail(3)) SWIG_fail;
5731 }
5732 {
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 {
5735 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5736 result = (wxRect *) &_result_ref;
5737 }
5738
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj;
5751 wxRect *arg1 = (wxRect *) 0 ;
5752 int arg2 ;
5753 int arg3 ;
5754 wxRect *result;
5755 PyObject * obj0 = 0 ;
5756 PyObject * obj1 = 0 ;
5757 PyObject * obj2 = 0 ;
5758 char *kwnames[] = {
5759 (char *) "self",(char *) "dx",(char *) "dy", NULL
5760 };
5761
5762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5764 if (SWIG_arg_fail(1)) SWIG_fail;
5765 {
5766 arg2 = (int)(SWIG_As_int(obj1));
5767 if (SWIG_arg_fail(2)) SWIG_fail;
5768 }
5769 {
5770 arg3 = (int)(SWIG_As_int(obj2));
5771 if (SWIG_arg_fail(3)) SWIG_fail;
5772 }
5773 {
5774 PyThreadState* __tstate = wxPyBeginAllowThreads();
5775 {
5776 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5777 result = (wxRect *) &_result_ref;
5778 }
5779
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj;
5792 wxRect *arg1 = (wxRect *) 0 ;
5793 int arg2 ;
5794 int arg3 ;
5795 PyObject * obj0 = 0 ;
5796 PyObject * obj1 = 0 ;
5797 PyObject * obj2 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "self",(char *) "dx",(char *) "dy", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5804 if (SWIG_arg_fail(1)) SWIG_fail;
5805 {
5806 arg2 = (int)(SWIG_As_int(obj1));
5807 if (SWIG_arg_fail(2)) SWIG_fail;
5808 }
5809 {
5810 arg3 = (int)(SWIG_As_int(obj2));
5811 if (SWIG_arg_fail(3)) SWIG_fail;
5812 }
5813 {
5814 PyThreadState* __tstate = wxPyBeginAllowThreads();
5815 (arg1)->Offset(arg2,arg3);
5816
5817 wxPyEndAllowThreads(__tstate);
5818 if (PyErr_Occurred()) SWIG_fail;
5819 }
5820 Py_INCREF(Py_None); resultobj = Py_None;
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj;
5829 wxRect *arg1 = (wxRect *) 0 ;
5830 wxPoint *arg2 = 0 ;
5831 wxPoint temp2 ;
5832 PyObject * obj0 = 0 ;
5833 PyObject * obj1 = 0 ;
5834 char *kwnames[] = {
5835 (char *) "self",(char *) "pt", NULL
5836 };
5837
5838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5840 if (SWIG_arg_fail(1)) SWIG_fail;
5841 {
5842 arg2 = &temp2;
5843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5844 }
5845 {
5846 PyThreadState* __tstate = wxPyBeginAllowThreads();
5847 (arg1)->Offset((wxPoint const &)*arg2);
5848
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 Py_INCREF(Py_None); resultobj = Py_None;
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj;
5861 wxRect *arg1 = (wxRect *) 0 ;
5862 wxRect *arg2 = 0 ;
5863 wxRect result;
5864 wxRect temp2 ;
5865 PyObject * obj0 = 0 ;
5866 PyObject * obj1 = 0 ;
5867 char *kwnames[] = {
5868 (char *) "self",(char *) "rect", NULL
5869 };
5870
5871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5873 if (SWIG_arg_fail(1)) SWIG_fail;
5874 {
5875 arg2 = &temp2;
5876 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5877 }
5878 {
5879 PyThreadState* __tstate = wxPyBeginAllowThreads();
5880 result = (arg1)->Intersect((wxRect const &)*arg2);
5881
5882 wxPyEndAllowThreads(__tstate);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 {
5886 wxRect * resultptr;
5887 resultptr = new wxRect((wxRect &)(result));
5888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5889 }
5890 return resultobj;
5891 fail:
5892 return NULL;
5893 }
5894
5895
5896 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5897 PyObject *resultobj;
5898 wxRect *arg1 = (wxRect *) 0 ;
5899 wxRect *arg2 = 0 ;
5900 wxRect result;
5901 wxRect temp2 ;
5902 PyObject * obj0 = 0 ;
5903 PyObject * obj1 = 0 ;
5904 char *kwnames[] = {
5905 (char *) "self",(char *) "rect", NULL
5906 };
5907
5908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5910 if (SWIG_arg_fail(1)) SWIG_fail;
5911 {
5912 arg2 = &temp2;
5913 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5914 }
5915 {
5916 PyThreadState* __tstate = wxPyBeginAllowThreads();
5917 result = (arg1)->Union((wxRect const &)*arg2);
5918
5919 wxPyEndAllowThreads(__tstate);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 {
5923 wxRect * resultptr;
5924 resultptr = new wxRect((wxRect &)(result));
5925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5926 }
5927 return resultobj;
5928 fail:
5929 return NULL;
5930 }
5931
5932
5933 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5934 PyObject *resultobj;
5935 wxRect *arg1 = (wxRect *) 0 ;
5936 wxRect *arg2 = 0 ;
5937 wxRect result;
5938 wxRect temp2 ;
5939 PyObject * obj0 = 0 ;
5940 PyObject * obj1 = 0 ;
5941 char *kwnames[] = {
5942 (char *) "self",(char *) "rect", NULL
5943 };
5944
5945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5947 if (SWIG_arg_fail(1)) SWIG_fail;
5948 {
5949 arg2 = &temp2;
5950 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5951 }
5952 {
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5955
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 {
5960 wxRect * resultptr;
5961 resultptr = new wxRect((wxRect &)(result));
5962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5963 }
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5971 PyObject *resultobj;
5972 wxRect *arg1 = (wxRect *) 0 ;
5973 wxRect *arg2 = 0 ;
5974 wxRect *result;
5975 wxRect temp2 ;
5976 PyObject * obj0 = 0 ;
5977 PyObject * obj1 = 0 ;
5978 char *kwnames[] = {
5979 (char *) "self",(char *) "rect", NULL
5980 };
5981
5982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5984 if (SWIG_arg_fail(1)) SWIG_fail;
5985 {
5986 arg2 = &temp2;
5987 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5988 }
5989 {
5990 PyThreadState* __tstate = wxPyBeginAllowThreads();
5991 {
5992 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5993 result = (wxRect *) &_result_ref;
5994 }
5995
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6000 return resultobj;
6001 fail:
6002 return NULL;
6003 }
6004
6005
6006 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj;
6008 wxRect *arg1 = (wxRect *) 0 ;
6009 wxRect *arg2 = 0 ;
6010 bool result;
6011 wxRect temp2 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 char *kwnames[] = {
6015 (char *) "self",(char *) "rect", NULL
6016 };
6017
6018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6020 if (SWIG_arg_fail(1)) SWIG_fail;
6021 {
6022 arg2 = &temp2;
6023 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6024 }
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 {
6033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6034 }
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj;
6043 wxRect *arg1 = (wxRect *) 0 ;
6044 wxRect *arg2 = 0 ;
6045 bool result;
6046 wxRect temp2 ;
6047 PyObject * obj0 = 0 ;
6048 PyObject * obj1 = 0 ;
6049 char *kwnames[] = {
6050 (char *) "self",(char *) "rect", NULL
6051 };
6052
6053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6055 if (SWIG_arg_fail(1)) SWIG_fail;
6056 {
6057 arg2 = &temp2;
6058 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6059 }
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj;
6078 wxRect *arg1 = (wxRect *) 0 ;
6079 int arg2 ;
6080 int arg3 ;
6081 bool result;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 PyObject * obj2 = 0 ;
6085 char *kwnames[] = {
6086 (char *) "self",(char *) "x",(char *) "y", NULL
6087 };
6088
6089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6091 if (SWIG_arg_fail(1)) SWIG_fail;
6092 {
6093 arg2 = (int)(SWIG_As_int(obj1));
6094 if (SWIG_arg_fail(2)) SWIG_fail;
6095 }
6096 {
6097 arg3 = (int)(SWIG_As_int(obj2));
6098 if (SWIG_arg_fail(3)) SWIG_fail;
6099 }
6100 {
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6103
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6109 }
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 wxRect *arg1 = (wxRect *) 0 ;
6119 wxPoint *arg2 = 0 ;
6120 bool result;
6121 wxPoint temp2 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char *kwnames[] = {
6125 (char *) "self",(char *) "pt", NULL
6126 };
6127
6128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6130 if (SWIG_arg_fail(1)) SWIG_fail;
6131 {
6132 arg2 = &temp2;
6133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6134 }
6135 {
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6138
6139 wxPyEndAllowThreads(__tstate);
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 {
6143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6144 }
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj;
6153 wxRect *arg1 = (wxRect *) 0 ;
6154 wxRect *arg2 = 0 ;
6155 bool result;
6156 wxRect temp2 ;
6157 PyObject * obj0 = 0 ;
6158 PyObject * obj1 = 0 ;
6159 char *kwnames[] = {
6160 (char *) "self",(char *) "rect", NULL
6161 };
6162
6163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6165 if (SWIG_arg_fail(1)) SWIG_fail;
6166 {
6167 arg2 = &temp2;
6168 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6169 }
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 {
6178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6179 }
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj;
6188 wxRect *arg1 = (wxRect *) 0 ;
6189 int arg2 ;
6190 PyObject * obj0 = 0 ;
6191 PyObject * obj1 = 0 ;
6192 char *kwnames[] = {
6193 (char *) "self",(char *) "x", NULL
6194 };
6195
6196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6198 if (SWIG_arg_fail(1)) SWIG_fail;
6199 {
6200 arg2 = (int)(SWIG_As_int(obj1));
6201 if (SWIG_arg_fail(2)) SWIG_fail;
6202 }
6203 if (arg1) (arg1)->x = arg2;
6204
6205 Py_INCREF(Py_None); resultobj = Py_None;
6206 return resultobj;
6207 fail:
6208 return NULL;
6209 }
6210
6211
6212 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6213 PyObject *resultobj;
6214 wxRect *arg1 = (wxRect *) 0 ;
6215 int result;
6216 PyObject * obj0 = 0 ;
6217 char *kwnames[] = {
6218 (char *) "self", NULL
6219 };
6220
6221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6223 if (SWIG_arg_fail(1)) SWIG_fail;
6224 result = (int) ((arg1)->x);
6225
6226 {
6227 resultobj = SWIG_From_int((int)(result));
6228 }
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 int arg2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "self",(char *) "y", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6247 if (SWIG_arg_fail(1)) SWIG_fail;
6248 {
6249 arg2 = (int)(SWIG_As_int(obj1));
6250 if (SWIG_arg_fail(2)) SWIG_fail;
6251 }
6252 if (arg1) (arg1)->y = arg2;
6253
6254 Py_INCREF(Py_None); resultobj = Py_None;
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj;
6263 wxRect *arg1 = (wxRect *) 0 ;
6264 int result;
6265 PyObject * obj0 = 0 ;
6266 char *kwnames[] = {
6267 (char *) "self", NULL
6268 };
6269
6270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6272 if (SWIG_arg_fail(1)) SWIG_fail;
6273 result = (int) ((arg1)->y);
6274
6275 {
6276 resultobj = SWIG_From_int((int)(result));
6277 }
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj;
6286 wxRect *arg1 = (wxRect *) 0 ;
6287 int arg2 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 char *kwnames[] = {
6291 (char *) "self",(char *) "width", NULL
6292 };
6293
6294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6296 if (SWIG_arg_fail(1)) SWIG_fail;
6297 {
6298 arg2 = (int)(SWIG_As_int(obj1));
6299 if (SWIG_arg_fail(2)) SWIG_fail;
6300 }
6301 if (arg1) (arg1)->width = arg2;
6302
6303 Py_INCREF(Py_None); resultobj = Py_None;
6304 return resultobj;
6305 fail:
6306 return NULL;
6307 }
6308
6309
6310 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6311 PyObject *resultobj;
6312 wxRect *arg1 = (wxRect *) 0 ;
6313 int result;
6314 PyObject * obj0 = 0 ;
6315 char *kwnames[] = {
6316 (char *) "self", NULL
6317 };
6318
6319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6321 if (SWIG_arg_fail(1)) SWIG_fail;
6322 result = (int) ((arg1)->width);
6323
6324 {
6325 resultobj = SWIG_From_int((int)(result));
6326 }
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6334 PyObject *resultobj;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int arg2 ;
6337 PyObject * obj0 = 0 ;
6338 PyObject * obj1 = 0 ;
6339 char *kwnames[] = {
6340 (char *) "self",(char *) "height", NULL
6341 };
6342
6343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 {
6347 arg2 = (int)(SWIG_As_int(obj1));
6348 if (SWIG_arg_fail(2)) SWIG_fail;
6349 }
6350 if (arg1) (arg1)->height = arg2;
6351
6352 Py_INCREF(Py_None); resultobj = Py_None;
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 int result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6370 if (SWIG_arg_fail(1)) SWIG_fail;
6371 result = (int) ((arg1)->height);
6372
6373 {
6374 resultobj = SWIG_From_int((int)(result));
6375 }
6376 return resultobj;
6377 fail:
6378 return NULL;
6379 }
6380
6381
6382 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6383 PyObject *resultobj;
6384 wxRect *arg1 = (wxRect *) 0 ;
6385 int arg2 = (int) 0 ;
6386 int arg3 = (int) 0 ;
6387 int arg4 = (int) 0 ;
6388 int arg5 = (int) 0 ;
6389 PyObject * obj0 = 0 ;
6390 PyObject * obj1 = 0 ;
6391 PyObject * obj2 = 0 ;
6392 PyObject * obj3 = 0 ;
6393 PyObject * obj4 = 0 ;
6394 char *kwnames[] = {
6395 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6396 };
6397
6398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6400 if (SWIG_arg_fail(1)) SWIG_fail;
6401 if (obj1) {
6402 {
6403 arg2 = (int)(SWIG_As_int(obj1));
6404 if (SWIG_arg_fail(2)) SWIG_fail;
6405 }
6406 }
6407 if (obj2) {
6408 {
6409 arg3 = (int)(SWIG_As_int(obj2));
6410 if (SWIG_arg_fail(3)) SWIG_fail;
6411 }
6412 }
6413 if (obj3) {
6414 {
6415 arg4 = (int)(SWIG_As_int(obj3));
6416 if (SWIG_arg_fail(4)) SWIG_fail;
6417 }
6418 }
6419 if (obj4) {
6420 {
6421 arg5 = (int)(SWIG_As_int(obj4));
6422 if (SWIG_arg_fail(5)) SWIG_fail;
6423 }
6424 }
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6428
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 Py_INCREF(Py_None); resultobj = Py_None;
6433 return resultobj;
6434 fail:
6435 return NULL;
6436 }
6437
6438
6439 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6440 PyObject *resultobj;
6441 wxRect *arg1 = (wxRect *) 0 ;
6442 PyObject *result;
6443 PyObject * obj0 = 0 ;
6444 char *kwnames[] = {
6445 (char *) "self", NULL
6446 };
6447
6448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6450 if (SWIG_arg_fail(1)) SWIG_fail;
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (PyObject *)wxRect_Get(arg1);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = result;
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6466 PyObject *obj;
6467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6468 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6469 Py_INCREF(obj);
6470 return Py_BuildValue((char *)"");
6471 }
6472 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxRect *arg1 = (wxRect *) 0 ;
6475 wxRect *arg2 = (wxRect *) 0 ;
6476 PyObject *result;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "r1",(char *) "r2", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6485 if (SWIG_arg_fail(1)) SWIG_fail;
6486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6487 if (SWIG_arg_fail(2)) SWIG_fail;
6488 {
6489 if (!wxPyCheckForApp()) SWIG_fail;
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (PyObject *)wxIntersectRect(arg1,arg2);
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = result;
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj;
6505 double arg1 = (double) 0.0 ;
6506 double arg2 = (double) 0.0 ;
6507 wxPoint2D *result;
6508 PyObject * obj0 = 0 ;
6509 PyObject * obj1 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "x",(char *) "y", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6515 if (obj0) {
6516 {
6517 arg1 = (double)(SWIG_As_double(obj0));
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 }
6520 }
6521 if (obj1) {
6522 {
6523 arg2 = (double)(SWIG_As_double(obj1));
6524 if (SWIG_arg_fail(2)) SWIG_fail;
6525 }
6526 }
6527 {
6528 PyThreadState* __tstate = wxPyBeginAllowThreads();
6529 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6530
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6542 PyObject *resultobj;
6543 wxPoint2D *arg1 = 0 ;
6544 wxPoint2D *result;
6545 wxPoint2D temp1 ;
6546 PyObject * obj0 = 0 ;
6547 char *kwnames[] = {
6548 (char *) "pt", NULL
6549 };
6550
6551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6552 {
6553 arg1 = &temp1;
6554 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6555 }
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6559
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj;
6572 wxPoint *arg1 = 0 ;
6573 wxPoint2D *result;
6574 wxPoint temp1 ;
6575 PyObject * obj0 = 0 ;
6576 char *kwnames[] = {
6577 (char *) "pt", NULL
6578 };
6579
6580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6581 {
6582 arg1 = &temp1;
6583 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6584 }
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6588
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj;
6601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6602 int *arg2 = (int *) 0 ;
6603 int *arg3 = (int *) 0 ;
6604 int temp2 ;
6605 int res2 = 0 ;
6606 int temp3 ;
6607 int res3 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 char *kwnames[] = {
6610 (char *) "self", NULL
6611 };
6612
6613 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6614 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 Py_INCREF(Py_None); resultobj = Py_None;
6626 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6627 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6628 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6629 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj;
6638 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6639 int *arg2 = (int *) 0 ;
6640 int *arg3 = (int *) 0 ;
6641 int temp2 ;
6642 int res2 = 0 ;
6643 int temp3 ;
6644 int res3 = 0 ;
6645 PyObject * obj0 = 0 ;
6646 char *kwnames[] = {
6647 (char *) "self", NULL
6648 };
6649
6650 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6651 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6654 if (SWIG_arg_fail(1)) SWIG_fail;
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6658
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 Py_INCREF(Py_None); resultobj = Py_None;
6663 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6664 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6665 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6666 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6674 PyObject *resultobj;
6675 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6676 double result;
6677 PyObject * obj0 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self", NULL
6680 };
6681
6682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(1)) SWIG_fail;
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6688
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 {
6693 resultobj = SWIG_From_double((double)(result));
6694 }
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6702 PyObject *resultobj;
6703 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6704 double result;
6705 PyObject * obj0 = 0 ;
6706 char *kwnames[] = {
6707 (char *) "self", NULL
6708 };
6709
6710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6712 if (SWIG_arg_fail(1)) SWIG_fail;
6713 {
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6716
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 {
6721 resultobj = SWIG_From_double((double)(result));
6722 }
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6730 PyObject *resultobj;
6731 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6732 double arg2 ;
6733 PyObject * obj0 = 0 ;
6734 PyObject * obj1 = 0 ;
6735 char *kwnames[] = {
6736 (char *) "self",(char *) "length", NULL
6737 };
6738
6739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6741 if (SWIG_arg_fail(1)) SWIG_fail;
6742 {
6743 arg2 = (double)(SWIG_As_double(obj1));
6744 if (SWIG_arg_fail(2)) SWIG_fail;
6745 }
6746 {
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 (arg1)->SetVectorLength(arg2);
6749
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 Py_INCREF(Py_None); resultobj = Py_None;
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6761 PyObject *resultobj;
6762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6763 double arg2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "self",(char *) "degrees", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6772 if (SWIG_arg_fail(1)) SWIG_fail;
6773 {
6774 arg2 = (double)(SWIG_As_double(obj1));
6775 if (SWIG_arg_fail(2)) SWIG_fail;
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 (arg1)->SetVectorAngle(arg2);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 Py_INCREF(Py_None); resultobj = Py_None;
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj;
6793 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6794 wxPoint2D *arg2 = 0 ;
6795 double result;
6796 wxPoint2D temp2 ;
6797 PyObject * obj0 = 0 ;
6798 PyObject * obj1 = 0 ;
6799 char *kwnames[] = {
6800 (char *) "self",(char *) "pt", NULL
6801 };
6802
6803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6805 if (SWIG_arg_fail(1)) SWIG_fail;
6806 {
6807 arg2 = &temp2;
6808 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6809 }
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 {
6818 resultobj = SWIG_From_double((double)(result));
6819 }
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6827 PyObject *resultobj;
6828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6829 wxPoint2D *arg2 = 0 ;
6830 double result;
6831 wxPoint2D temp2 ;
6832 PyObject * obj0 = 0 ;
6833 PyObject * obj1 = 0 ;
6834 char *kwnames[] = {
6835 (char *) "self",(char *) "pt", NULL
6836 };
6837
6838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6840 if (SWIG_arg_fail(1)) SWIG_fail;
6841 {
6842 arg2 = &temp2;
6843 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6844 }
6845 {
6846 PyThreadState* __tstate = wxPyBeginAllowThreads();
6847 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6848
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 {
6853 resultobj = SWIG_From_double((double)(result));
6854 }
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj;
6863 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6864 wxPoint2D *arg2 = 0 ;
6865 double result;
6866 wxPoint2D temp2 ;
6867 PyObject * obj0 = 0 ;
6868 PyObject * obj1 = 0 ;
6869 char *kwnames[] = {
6870 (char *) "self",(char *) "vec", NULL
6871 };
6872
6873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 {
6877 arg2 = &temp2;
6878 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6879 }
6880 {
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6883
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 {
6888 resultobj = SWIG_From_double((double)(result));
6889 }
6890 return resultobj;
6891 fail:
6892 return NULL;
6893 }
6894
6895
6896 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6897 PyObject *resultobj;
6898 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6899 wxPoint2D *arg2 = 0 ;
6900 double result;
6901 wxPoint2D temp2 ;
6902 PyObject * obj0 = 0 ;
6903 PyObject * obj1 = 0 ;
6904 char *kwnames[] = {
6905 (char *) "self",(char *) "vec", NULL
6906 };
6907
6908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6910 if (SWIG_arg_fail(1)) SWIG_fail;
6911 {
6912 arg2 = &temp2;
6913 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6914 }
6915 {
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6918
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 {
6923 resultobj = SWIG_From_double((double)(result));
6924 }
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6932 PyObject *resultobj;
6933 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6934 wxPoint2D result;
6935 PyObject * obj0 = 0 ;
6936 char *kwnames[] = {
6937 (char *) "self", NULL
6938 };
6939
6940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6942 if (SWIG_arg_fail(1)) SWIG_fail;
6943 {
6944 PyThreadState* __tstate = wxPyBeginAllowThreads();
6945 result = (arg1)->operator -();
6946
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 {
6951 wxPoint2D * resultptr;
6952 resultptr = new wxPoint2D((wxPoint2D &)(result));
6953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6964 wxPoint2D *arg2 = 0 ;
6965 wxPoint2D *result;
6966 wxPoint2D temp2 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char *kwnames[] = {
6970 (char *) "self",(char *) "pt", NULL
6971 };
6972
6973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6975 if (SWIG_arg_fail(1)) SWIG_fail;
6976 {
6977 arg2 = &temp2;
6978 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6979 }
6980 {
6981 PyThreadState* __tstate = wxPyBeginAllowThreads();
6982 {
6983 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6984 result = (wxPoint2D *) &_result_ref;
6985 }
6986
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6998 PyObject *resultobj;
6999 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7000 wxPoint2D *arg2 = 0 ;
7001 wxPoint2D *result;
7002 wxPoint2D temp2 ;
7003 PyObject * obj0 = 0 ;
7004 PyObject * obj1 = 0 ;
7005 char *kwnames[] = {
7006 (char *) "self",(char *) "pt", NULL
7007 };
7008
7009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7011 if (SWIG_arg_fail(1)) SWIG_fail;
7012 {
7013 arg2 = &temp2;
7014 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7015 }
7016 {
7017 PyThreadState* __tstate = wxPyBeginAllowThreads();
7018 {
7019 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7020 result = (wxPoint2D *) &_result_ref;
7021 }
7022
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj;
7035 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7036 wxPoint2D *arg2 = 0 ;
7037 wxPoint2D *result;
7038 wxPoint2D temp2 ;
7039 PyObject * obj0 = 0 ;
7040 PyObject * obj1 = 0 ;
7041 char *kwnames[] = {
7042 (char *) "self",(char *) "pt", NULL
7043 };
7044
7045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7047 if (SWIG_arg_fail(1)) SWIG_fail;
7048 {
7049 arg2 = &temp2;
7050 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7051 }
7052 {
7053 PyThreadState* __tstate = wxPyBeginAllowThreads();
7054 {
7055 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7056 result = (wxPoint2D *) &_result_ref;
7057 }
7058
7059 wxPyEndAllowThreads(__tstate);
7060 if (PyErr_Occurred()) SWIG_fail;
7061 }
7062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7063 return resultobj;
7064 fail:
7065 return NULL;
7066 }
7067
7068
7069 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7070 PyObject *resultobj;
7071 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7072 wxPoint2D *arg2 = 0 ;
7073 wxPoint2D *result;
7074 wxPoint2D temp2 ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 char *kwnames[] = {
7078 (char *) "self",(char *) "pt", NULL
7079 };
7080
7081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7083 if (SWIG_arg_fail(1)) SWIG_fail;
7084 {
7085 arg2 = &temp2;
7086 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7087 }
7088 {
7089 PyThreadState* __tstate = wxPyBeginAllowThreads();
7090 {
7091 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7092 result = (wxPoint2D *) &_result_ref;
7093 }
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj;
7107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7108 wxPoint2D *arg2 = 0 ;
7109 bool result;
7110 wxPoint2D temp2 ;
7111 PyObject * obj0 = 0 ;
7112 PyObject * obj1 = 0 ;
7113 char *kwnames[] = {
7114 (char *) "self",(char *) "pt", NULL
7115 };
7116
7117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7119 if (SWIG_arg_fail(1)) SWIG_fail;
7120 {
7121 arg2 = &temp2;
7122 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7123 }
7124 {
7125 PyThreadState* __tstate = wxPyBeginAllowThreads();
7126 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7127
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7133 }
7134 return resultobj;
7135 fail:
7136 return NULL;
7137 }
7138
7139
7140 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7141 PyObject *resultobj;
7142 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7143 wxPoint2D *arg2 = 0 ;
7144 bool result;
7145 wxPoint2D temp2 ;
7146 PyObject * obj0 = 0 ;
7147 PyObject * obj1 = 0 ;
7148 char *kwnames[] = {
7149 (char *) "self",(char *) "pt", NULL
7150 };
7151
7152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(1)) SWIG_fail;
7155 {
7156 arg2 = &temp2;
7157 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7158 }
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7162
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 {
7167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7168 }
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj;
7177 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7178 double arg2 ;
7179 PyObject * obj0 = 0 ;
7180 PyObject * obj1 = 0 ;
7181 char *kwnames[] = {
7182 (char *) "self",(char *) "m_x", NULL
7183 };
7184
7185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7187 if (SWIG_arg_fail(1)) SWIG_fail;
7188 {
7189 arg2 = (double)(SWIG_As_double(obj1));
7190 if (SWIG_arg_fail(2)) SWIG_fail;
7191 }
7192 if (arg1) (arg1)->m_x = arg2;
7193
7194 Py_INCREF(Py_None); resultobj = Py_None;
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj;
7203 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7204 double result;
7205 PyObject * obj0 = 0 ;
7206 char *kwnames[] = {
7207 (char *) "self", NULL
7208 };
7209
7210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7212 if (SWIG_arg_fail(1)) SWIG_fail;
7213 result = (double) ((arg1)->m_x);
7214
7215 {
7216 resultobj = SWIG_From_double((double)(result));
7217 }
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj;
7226 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7227 double arg2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self",(char *) "m_y", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 {
7238 arg2 = (double)(SWIG_As_double(obj1));
7239 if (SWIG_arg_fail(2)) SWIG_fail;
7240 }
7241 if (arg1) (arg1)->m_y = arg2;
7242
7243 Py_INCREF(Py_None); resultobj = Py_None;
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7251 PyObject *resultobj;
7252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7253 double result;
7254 PyObject * obj0 = 0 ;
7255 char *kwnames[] = {
7256 (char *) "self", NULL
7257 };
7258
7259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7261 if (SWIG_arg_fail(1)) SWIG_fail;
7262 result = (double) ((arg1)->m_y);
7263
7264 {
7265 resultobj = SWIG_From_double((double)(result));
7266 }
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj;
7275 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7276 double arg2 = (double) 0 ;
7277 double arg3 = (double) 0 ;
7278 PyObject * obj0 = 0 ;
7279 PyObject * obj1 = 0 ;
7280 PyObject * obj2 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self",(char *) "x",(char *) "y", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 if (obj1) {
7289 {
7290 arg2 = (double)(SWIG_As_double(obj1));
7291 if (SWIG_arg_fail(2)) SWIG_fail;
7292 }
7293 }
7294 if (obj2) {
7295 {
7296 arg3 = (double)(SWIG_As_double(obj2));
7297 if (SWIG_arg_fail(3)) SWIG_fail;
7298 }
7299 }
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 wxPoint2D_Set(arg1,arg2,arg3);
7303
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 Py_INCREF(Py_None); resultobj = Py_None;
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj;
7316 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7317 PyObject *result;
7318 PyObject * obj0 = 0 ;
7319 char *kwnames[] = {
7320 (char *) "self", NULL
7321 };
7322
7323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7325 if (SWIG_arg_fail(1)) SWIG_fail;
7326 {
7327 PyThreadState* __tstate = wxPyBeginAllowThreads();
7328 result = (PyObject *)wxPoint2D_Get(arg1);
7329
7330 wxPyEndAllowThreads(__tstate);
7331 if (PyErr_Occurred()) SWIG_fail;
7332 }
7333 resultobj = result;
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7341 PyObject *obj;
7342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7343 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7344 Py_INCREF(obj);
7345 return Py_BuildValue((char *)"");
7346 }
7347 static int _wrap_DefaultPosition_set(PyObject *) {
7348 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7349 return 1;
7350 }
7351
7352
7353 static PyObject *_wrap_DefaultPosition_get(void) {
7354 PyObject *pyobj;
7355
7356 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7357 return pyobj;
7358 }
7359
7360
7361 static int _wrap_DefaultSize_set(PyObject *) {
7362 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7363 return 1;
7364 }
7365
7366
7367 static PyObject *_wrap_DefaultSize_get(void) {
7368 PyObject *pyobj;
7369
7370 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7371 return pyobj;
7372 }
7373
7374
7375 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7376 PyObject *resultobj;
7377 PyObject *arg1 = (PyObject *) 0 ;
7378 wxPyInputStream *result;
7379 PyObject * obj0 = 0 ;
7380 char *kwnames[] = {
7381 (char *) "p", NULL
7382 };
7383
7384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7385 arg1 = obj0;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7389
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj;
7402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7403 PyObject * obj0 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 delete arg1;
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 Py_INCREF(Py_None); resultobj = Py_None;
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7428 PyObject * obj0 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->close();
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 Py_INCREF(Py_None); resultobj = Py_None;
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj;
7452 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7453 PyObject * obj0 = 0 ;
7454 char *kwnames[] = {
7455 (char *) "self", NULL
7456 };
7457
7458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(1)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 (arg1)->flush();
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 Py_INCREF(Py_None); resultobj = Py_None;
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj;
7477 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7478 bool result;
7479 PyObject * obj0 = 0 ;
7480 char *kwnames[] = {
7481 (char *) "self", NULL
7482 };
7483
7484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7486 if (SWIG_arg_fail(1)) SWIG_fail;
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)(arg1)->eof();
7490
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 {
7495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7496 }
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj;
7505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7506 int arg2 = (int) -1 ;
7507 PyObject *result;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char *kwnames[] = {
7511 (char *) "self",(char *) "size", NULL
7512 };
7513
7514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7516 if (SWIG_arg_fail(1)) SWIG_fail;
7517 if (obj1) {
7518 {
7519 arg2 = (int)(SWIG_As_int(obj1));
7520 if (SWIG_arg_fail(2)) SWIG_fail;
7521 }
7522 }
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (PyObject *)(arg1)->read(arg2);
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = result;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7540 int arg2 = (int) -1 ;
7541 PyObject *result;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 char *kwnames[] = {
7545 (char *) "self",(char *) "size", NULL
7546 };
7547
7548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7550 if (SWIG_arg_fail(1)) SWIG_fail;
7551 if (obj1) {
7552 {
7553 arg2 = (int)(SWIG_As_int(obj1));
7554 if (SWIG_arg_fail(2)) SWIG_fail;
7555 }
7556 }
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (PyObject *)(arg1)->readline(arg2);
7560
7561 wxPyEndAllowThreads(__tstate);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 resultobj = result;
7565 return resultobj;
7566 fail:
7567 return NULL;
7568 }
7569
7570
7571 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7572 PyObject *resultobj;
7573 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7574 int arg2 = (int) -1 ;
7575 PyObject *result;
7576 PyObject * obj0 = 0 ;
7577 PyObject * obj1 = 0 ;
7578 char *kwnames[] = {
7579 (char *) "self",(char *) "sizehint", NULL
7580 };
7581
7582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7584 if (SWIG_arg_fail(1)) SWIG_fail;
7585 if (obj1) {
7586 {
7587 arg2 = (int)(SWIG_As_int(obj1));
7588 if (SWIG_arg_fail(2)) SWIG_fail;
7589 }
7590 }
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (PyObject *)(arg1)->readlines(arg2);
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 resultobj = result;
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj;
7607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7608 int arg2 ;
7609 int arg3 = (int) 0 ;
7610 PyObject * obj0 = 0 ;
7611 PyObject * obj1 = 0 ;
7612 PyObject * obj2 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self",(char *) "offset",(char *) "whence", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 arg2 = (int)(SWIG_As_int(obj1));
7622 if (SWIG_arg_fail(2)) SWIG_fail;
7623 }
7624 if (obj2) {
7625 {
7626 arg3 = (int)(SWIG_As_int(obj2));
7627 if (SWIG_arg_fail(3)) SWIG_fail;
7628 }
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->seek(arg2,arg3);
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 Py_INCREF(Py_None); resultobj = Py_None;
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj;
7646 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7647 int result;
7648 PyObject * obj0 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "self", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7655 if (SWIG_arg_fail(1)) SWIG_fail;
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (int)(arg1)->tell();
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 resultobj = SWIG_From_int((int)(result));
7665 }
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj;
7674 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7675 char result;
7676 PyObject * obj0 = 0 ;
7677 char *kwnames[] = {
7678 (char *) "self", NULL
7679 };
7680
7681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7683 if (SWIG_arg_fail(1)) SWIG_fail;
7684 {
7685 PyThreadState* __tstate = wxPyBeginAllowThreads();
7686 result = (char)(arg1)->Peek();
7687
7688 wxPyEndAllowThreads(__tstate);
7689 if (PyErr_Occurred()) SWIG_fail;
7690 }
7691 {
7692 resultobj = SWIG_From_char((char)(result));
7693 }
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj;
7702 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7703 char result;
7704 PyObject * obj0 = 0 ;
7705 char *kwnames[] = {
7706 (char *) "self", NULL
7707 };
7708
7709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7711 if (SWIG_arg_fail(1)) SWIG_fail;
7712 {
7713 PyThreadState* __tstate = wxPyBeginAllowThreads();
7714 result = (char)(arg1)->GetC();
7715
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 {
7720 resultobj = SWIG_From_char((char)(result));
7721 }
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7731 size_t result;
7732 PyObject * obj0 = 0 ;
7733 char *kwnames[] = {
7734 (char *) "self", NULL
7735 };
7736
7737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7739 if (SWIG_arg_fail(1)) SWIG_fail;
7740 {
7741 PyThreadState* __tstate = wxPyBeginAllowThreads();
7742 result = (size_t)(arg1)->LastRead();
7743
7744 wxPyEndAllowThreads(__tstate);
7745 if (PyErr_Occurred()) SWIG_fail;
7746 }
7747 {
7748 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7749 }
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj;
7758 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7759 bool result;
7760 PyObject * obj0 = 0 ;
7761 char *kwnames[] = {
7762 (char *) "self", NULL
7763 };
7764
7765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7767 if (SWIG_arg_fail(1)) SWIG_fail;
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 result = (bool)(arg1)->CanRead();
7771
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 {
7776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777 }
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj;
7786 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7787 bool result;
7788 PyObject * obj0 = 0 ;
7789 char *kwnames[] = {
7790 (char *) "self", NULL
7791 };
7792
7793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7795 if (SWIG_arg_fail(1)) SWIG_fail;
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (bool)(arg1)->Eof();
7799
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 {
7804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7805 }
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj;
7814 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7815 char arg2 ;
7816 bool result;
7817 PyObject * obj0 = 0 ;
7818 PyObject * obj1 = 0 ;
7819 char *kwnames[] = {
7820 (char *) "self",(char *) "c", NULL
7821 };
7822
7823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7825 if (SWIG_arg_fail(1)) SWIG_fail;
7826 {
7827 arg2 = (char)(SWIG_As_char(obj1));
7828 if (SWIG_arg_fail(2)) SWIG_fail;
7829 }
7830 {
7831 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 result = (bool)(arg1)->Ungetch(arg2);
7833
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj;
7848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7849 long arg2 ;
7850 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7851 long result;
7852 PyObject * obj0 = 0 ;
7853 PyObject * obj1 = 0 ;
7854 PyObject * obj2 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "self",(char *) "pos",(char *) "mode", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 {
7863 arg2 = (long)(SWIG_As_long(obj1));
7864 if (SWIG_arg_fail(2)) SWIG_fail;
7865 }
7866 if (obj2) {
7867 {
7868 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7869 if (SWIG_arg_fail(3)) SWIG_fail;
7870 }
7871 }
7872 {
7873 PyThreadState* __tstate = wxPyBeginAllowThreads();
7874 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7875
7876 wxPyEndAllowThreads(__tstate);
7877 if (PyErr_Occurred()) SWIG_fail;
7878 }
7879 {
7880 resultobj = SWIG_From_long((long)(result));
7881 }
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj;
7890 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7891 long result;
7892 PyObject * obj0 = 0 ;
7893 char *kwnames[] = {
7894 (char *) "self", NULL
7895 };
7896
7897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7899 if (SWIG_arg_fail(1)) SWIG_fail;
7900 {
7901 PyThreadState* __tstate = wxPyBeginAllowThreads();
7902 result = (long)(arg1)->TellI();
7903
7904 wxPyEndAllowThreads(__tstate);
7905 if (PyErr_Occurred()) SWIG_fail;
7906 }
7907 {
7908 resultobj = SWIG_From_long((long)(result));
7909 }
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7917 PyObject *obj;
7918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7919 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7920 Py_INCREF(obj);
7921 return Py_BuildValue((char *)"");
7922 }
7923 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7926 PyObject *arg2 = (PyObject *) 0 ;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self",(char *) "obj", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 arg2 = obj1;
7937 {
7938 PyThreadState* __tstate = wxPyBeginAllowThreads();
7939 wxOutputStream_write(arg1,arg2);
7940
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 Py_INCREF(Py_None); resultobj = Py_None;
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7952 PyObject *obj;
7953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7954 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7955 Py_INCREF(obj);
7956 return Py_BuildValue((char *)"");
7957 }
7958 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj;
7960 wxInputStream *arg1 = (wxInputStream *) 0 ;
7961 wxString *arg2 = 0 ;
7962 wxString *arg3 = 0 ;
7963 wxString *arg4 = 0 ;
7964 wxDateTime arg5 ;
7965 wxFSFile *result;
7966 wxPyInputStream *temp1 ;
7967 bool temp2 = false ;
7968 bool temp3 = false ;
7969 bool temp4 = false ;
7970 PyObject * obj0 = 0 ;
7971 PyObject * obj1 = 0 ;
7972 PyObject * obj2 = 0 ;
7973 PyObject * obj3 = 0 ;
7974 PyObject * obj4 = 0 ;
7975 char *kwnames[] = {
7976 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7977 };
7978
7979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7980 {
7981 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7982 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7983 } else {
7984 PyErr_Clear(); // clear the failure of the wxPyConvert above
7985 arg1 = wxPyCBInputStream_create(obj0, true);
7986 if (arg1 == NULL) {
7987 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7988 SWIG_fail;
7989 }
7990 }
7991 }
7992 {
7993 arg2 = wxString_in_helper(obj1);
7994 if (arg2 == NULL) SWIG_fail;
7995 temp2 = true;
7996 }
7997 {
7998 arg3 = wxString_in_helper(obj2);
7999 if (arg3 == NULL) SWIG_fail;
8000 temp3 = true;
8001 }
8002 {
8003 arg4 = wxString_in_helper(obj3);
8004 if (arg4 == NULL) SWIG_fail;
8005 temp4 = true;
8006 }
8007 {
8008 wxDateTime * argp;
8009 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8010 if (SWIG_arg_fail(5)) SWIG_fail;
8011 if (argp == NULL) {
8012 SWIG_null_ref("wxDateTime");
8013 }
8014 if (SWIG_arg_fail(5)) SWIG_fail;
8015 arg5 = *argp;
8016 }
8017 {
8018 PyThreadState* __tstate = wxPyBeginAllowThreads();
8019 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8020
8021 wxPyEndAllowThreads(__tstate);
8022 if (PyErr_Occurred()) SWIG_fail;
8023 }
8024 {
8025 resultobj = wxPyMake_wxObject(result, 1);
8026 }
8027 {
8028 if (temp2)
8029 delete arg2;
8030 }
8031 {
8032 if (temp3)
8033 delete arg3;
8034 }
8035 {
8036 if (temp4)
8037 delete arg4;
8038 }
8039 return resultobj;
8040 fail:
8041 {
8042 if (temp2)
8043 delete arg2;
8044 }
8045 {
8046 if (temp3)
8047 delete arg3;
8048 }
8049 {
8050 if (temp4)
8051 delete arg4;
8052 }
8053 return NULL;
8054 }
8055
8056
8057 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj;
8059 wxFSFile *arg1 = (wxFSFile *) 0 ;
8060 PyObject * obj0 = 0 ;
8061 char *kwnames[] = {
8062 (char *) "self", NULL
8063 };
8064
8065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8067 if (SWIG_arg_fail(1)) SWIG_fail;
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 delete arg1;
8071
8072 wxPyEndAllowThreads(__tstate);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 Py_INCREF(Py_None); resultobj = Py_None;
8076 return resultobj;
8077 fail:
8078 return NULL;
8079 }
8080
8081
8082 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8083 PyObject *resultobj;
8084 wxFSFile *arg1 = (wxFSFile *) 0 ;
8085 wxInputStream *result;
8086 PyObject * obj0 = 0 ;
8087 char *kwnames[] = {
8088 (char *) "self", NULL
8089 };
8090
8091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8093 if (SWIG_arg_fail(1)) SWIG_fail;
8094 {
8095 PyThreadState* __tstate = wxPyBeginAllowThreads();
8096 result = (wxInputStream *)(arg1)->GetStream();
8097
8098 wxPyEndAllowThreads(__tstate);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 {
8102 wxPyInputStream * _ptr = NULL;
8103
8104 if (result) {
8105 _ptr = new wxPyInputStream(result);
8106 }
8107 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8108 }
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8116 PyObject *resultobj;
8117 wxFSFile *arg1 = (wxFSFile *) 0 ;
8118 wxString *result;
8119 PyObject * obj0 = 0 ;
8120 char *kwnames[] = {
8121 (char *) "self", NULL
8122 };
8123
8124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8126 if (SWIG_arg_fail(1)) SWIG_fail;
8127 {
8128 PyThreadState* __tstate = wxPyBeginAllowThreads();
8129 {
8130 wxString const &_result_ref = (arg1)->GetMimeType();
8131 result = (wxString *) &_result_ref;
8132 }
8133
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 {
8138 #if wxUSE_UNICODE
8139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8140 #else
8141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8142 #endif
8143 }
8144 return resultobj;
8145 fail:
8146 return NULL;
8147 }
8148
8149
8150 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8151 PyObject *resultobj;
8152 wxFSFile *arg1 = (wxFSFile *) 0 ;
8153 wxString *result;
8154 PyObject * obj0 = 0 ;
8155 char *kwnames[] = {
8156 (char *) "self", NULL
8157 };
8158
8159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8161 if (SWIG_arg_fail(1)) SWIG_fail;
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 {
8165 wxString const &_result_ref = (arg1)->GetLocation();
8166 result = (wxString *) &_result_ref;
8167 }
8168
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 {
8173 #if wxUSE_UNICODE
8174 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8175 #else
8176 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8177 #endif
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj;
8187 wxFSFile *arg1 = (wxFSFile *) 0 ;
8188 wxString *result;
8189 PyObject * obj0 = 0 ;
8190 char *kwnames[] = {
8191 (char *) "self", NULL
8192 };
8193
8194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8196 if (SWIG_arg_fail(1)) SWIG_fail;
8197 {
8198 PyThreadState* __tstate = wxPyBeginAllowThreads();
8199 {
8200 wxString const &_result_ref = (arg1)->GetAnchor();
8201 result = (wxString *) &_result_ref;
8202 }
8203
8204 wxPyEndAllowThreads(__tstate);
8205 if (PyErr_Occurred()) SWIG_fail;
8206 }
8207 {
8208 #if wxUSE_UNICODE
8209 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8210 #else
8211 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8212 #endif
8213 }
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj;
8222 wxFSFile *arg1 = (wxFSFile *) 0 ;
8223 wxDateTime result;
8224 PyObject * obj0 = 0 ;
8225 char *kwnames[] = {
8226 (char *) "self", NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8231 if (SWIG_arg_fail(1)) SWIG_fail;
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (arg1)->GetModificationTime();
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 {
8240 wxDateTime * resultptr;
8241 resultptr = new wxDateTime((wxDateTime &)(result));
8242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8243 }
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8251 PyObject *obj;
8252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8253 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8254 Py_INCREF(obj);
8255 return Py_BuildValue((char *)"");
8256 }
8257 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8258 PyObject *obj;
8259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8260 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8261 Py_INCREF(obj);
8262 return Py_BuildValue((char *)"");
8263 }
8264 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyFileSystemHandler *result;
8267 char *kwnames[] = {
8268 NULL
8269 };
8270
8271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8275
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8280 return resultobj;
8281 fail:
8282 return NULL;
8283 }
8284
8285
8286 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj;
8288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8289 PyObject *arg2 = (PyObject *) 0 ;
8290 PyObject *arg3 = (PyObject *) 0 ;
8291 PyObject * obj0 = 0 ;
8292 PyObject * obj1 = 0 ;
8293 PyObject * obj2 = 0 ;
8294 char *kwnames[] = {
8295 (char *) "self",(char *) "self",(char *) "_class", NULL
8296 };
8297
8298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8300 if (SWIG_arg_fail(1)) SWIG_fail;
8301 arg2 = obj1;
8302 arg3 = obj2;
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 (arg1)->_setCallbackInfo(arg2,arg3);
8306
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 Py_INCREF(Py_None); resultobj = Py_None;
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj;
8319 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8320 wxString *arg2 = 0 ;
8321 bool result;
8322 bool temp2 = false ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 char *kwnames[] = {
8326 (char *) "self",(char *) "location", NULL
8327 };
8328
8329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8331 if (SWIG_arg_fail(1)) SWIG_fail;
8332 {
8333 arg2 = wxString_in_helper(obj1);
8334 if (arg2 == NULL) SWIG_fail;
8335 temp2 = true;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8346 }
8347 {
8348 if (temp2)
8349 delete arg2;
8350 }
8351 return resultobj;
8352 fail:
8353 {
8354 if (temp2)
8355 delete arg2;
8356 }
8357 return NULL;
8358 }
8359
8360
8361 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj;
8363 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8364 wxFileSystem *arg2 = 0 ;
8365 wxString *arg3 = 0 ;
8366 wxFSFile *result;
8367 bool temp3 = false ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 PyObject * obj2 = 0 ;
8371 char *kwnames[] = {
8372 (char *) "self",(char *) "fs",(char *) "location", NULL
8373 };
8374
8375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8377 if (SWIG_arg_fail(1)) SWIG_fail;
8378 {
8379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8380 if (SWIG_arg_fail(2)) SWIG_fail;
8381 if (arg2 == NULL) {
8382 SWIG_null_ref("wxFileSystem");
8383 }
8384 if (SWIG_arg_fail(2)) SWIG_fail;
8385 }
8386 {
8387 arg3 = wxString_in_helper(obj2);
8388 if (arg3 == NULL) SWIG_fail;
8389 temp3 = true;
8390 }
8391 {
8392 PyThreadState* __tstate = wxPyBeginAllowThreads();
8393 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8394
8395 wxPyEndAllowThreads(__tstate);
8396 if (PyErr_Occurred()) SWIG_fail;
8397 }
8398 {
8399 resultobj = wxPyMake_wxObject(result, 1);
8400 }
8401 {
8402 if (temp3)
8403 delete arg3;
8404 }
8405 return resultobj;
8406 fail:
8407 {
8408 if (temp3)
8409 delete arg3;
8410 }
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj;
8417 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8418 wxString *arg2 = 0 ;
8419 int arg3 = (int) 0 ;
8420 wxString result;
8421 bool temp2 = false ;
8422 PyObject * obj0 = 0 ;
8423 PyObject * obj1 = 0 ;
8424 PyObject * obj2 = 0 ;
8425 char *kwnames[] = {
8426 (char *) "self",(char *) "spec",(char *) "flags", NULL
8427 };
8428
8429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8431 if (SWIG_arg_fail(1)) SWIG_fail;
8432 {
8433 arg2 = wxString_in_helper(obj1);
8434 if (arg2 == NULL) SWIG_fail;
8435 temp2 = true;
8436 }
8437 if (obj2) {
8438 {
8439 arg3 = (int)(SWIG_As_int(obj2));
8440 if (SWIG_arg_fail(3)) SWIG_fail;
8441 }
8442 }
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8446
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 {
8451 #if wxUSE_UNICODE
8452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8453 #else
8454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8455 #endif
8456 }
8457 {
8458 if (temp2)
8459 delete arg2;
8460 }
8461 return resultobj;
8462 fail:
8463 {
8464 if (temp2)
8465 delete arg2;
8466 }
8467 return NULL;
8468 }
8469
8470
8471 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8472 PyObject *resultobj;
8473 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8474 wxString result;
8475 PyObject * obj0 = 0 ;
8476 char *kwnames[] = {
8477 (char *) "self", NULL
8478 };
8479
8480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8482 if (SWIG_arg_fail(1)) SWIG_fail;
8483 {
8484 PyThreadState* __tstate = wxPyBeginAllowThreads();
8485 result = (arg1)->FindNext();
8486
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 {
8491 #if wxUSE_UNICODE
8492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8493 #else
8494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8495 #endif
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8504 PyObject *resultobj;
8505 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8506 wxString *arg2 = 0 ;
8507 wxString result;
8508 bool temp2 = false ;
8509 PyObject * obj0 = 0 ;
8510 PyObject * obj1 = 0 ;
8511 char *kwnames[] = {
8512 (char *) "self",(char *) "location", NULL
8513 };
8514
8515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8517 if (SWIG_arg_fail(1)) SWIG_fail;
8518 {
8519 arg2 = wxString_in_helper(obj1);
8520 if (arg2 == NULL) SWIG_fail;
8521 temp2 = true;
8522 }
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 result = (arg1)->GetProtocol((wxString const &)*arg2);
8526
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 {
8531 #if wxUSE_UNICODE
8532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8533 #else
8534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8535 #endif
8536 }
8537 {
8538 if (temp2)
8539 delete arg2;
8540 }
8541 return resultobj;
8542 fail:
8543 {
8544 if (temp2)
8545 delete arg2;
8546 }
8547 return NULL;
8548 }
8549
8550
8551 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj;
8553 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8554 wxString *arg2 = 0 ;
8555 wxString result;
8556 bool temp2 = false ;
8557 PyObject * obj0 = 0 ;
8558 PyObject * obj1 = 0 ;
8559 char *kwnames[] = {
8560 (char *) "self",(char *) "location", NULL
8561 };
8562
8563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8565 if (SWIG_arg_fail(1)) SWIG_fail;
8566 {
8567 arg2 = wxString_in_helper(obj1);
8568 if (arg2 == NULL) SWIG_fail;
8569 temp2 = true;
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8574
8575 wxPyEndAllowThreads(__tstate);
8576 if (PyErr_Occurred()) SWIG_fail;
8577 }
8578 {
8579 #if wxUSE_UNICODE
8580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8581 #else
8582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8583 #endif
8584 }
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return resultobj;
8590 fail:
8591 {
8592 if (temp2)
8593 delete arg2;
8594 }
8595 return NULL;
8596 }
8597
8598
8599 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj;
8601 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8602 wxString *arg2 = 0 ;
8603 wxString result;
8604 bool temp2 = false ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 char *kwnames[] = {
8608 (char *) "self",(char *) "location", NULL
8609 };
8610
8611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 {
8615 arg2 = wxString_in_helper(obj1);
8616 if (arg2 == NULL) SWIG_fail;
8617 temp2 = true;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 result = (arg1)->GetAnchor((wxString const &)*arg2);
8622
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 {
8627 #if wxUSE_UNICODE
8628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8629 #else
8630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8631 #endif
8632 }
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 return resultobj;
8638 fail:
8639 {
8640 if (temp2)
8641 delete arg2;
8642 }
8643 return NULL;
8644 }
8645
8646
8647 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj;
8649 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8650 wxString *arg2 = 0 ;
8651 wxString result;
8652 bool temp2 = false ;
8653 PyObject * obj0 = 0 ;
8654 PyObject * obj1 = 0 ;
8655 char *kwnames[] = {
8656 (char *) "self",(char *) "location", NULL
8657 };
8658
8659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8661 if (SWIG_arg_fail(1)) SWIG_fail;
8662 {
8663 arg2 = wxString_in_helper(obj1);
8664 if (arg2 == NULL) SWIG_fail;
8665 temp2 = true;
8666 }
8667 {
8668 PyThreadState* __tstate = wxPyBeginAllowThreads();
8669 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8670
8671 wxPyEndAllowThreads(__tstate);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 {
8675 #if wxUSE_UNICODE
8676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8677 #else
8678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8679 #endif
8680 }
8681 {
8682 if (temp2)
8683 delete arg2;
8684 }
8685 return resultobj;
8686 fail:
8687 {
8688 if (temp2)
8689 delete arg2;
8690 }
8691 return NULL;
8692 }
8693
8694
8695 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8696 PyObject *resultobj;
8697 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8698 wxString *arg2 = 0 ;
8699 wxString result;
8700 bool temp2 = false ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char *kwnames[] = {
8704 (char *) "self",(char *) "location", NULL
8705 };
8706
8707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8709 if (SWIG_arg_fail(1)) SWIG_fail;
8710 {
8711 arg2 = wxString_in_helper(obj1);
8712 if (arg2 == NULL) SWIG_fail;
8713 temp2 = true;
8714 }
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8718
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 {
8723 #if wxUSE_UNICODE
8724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8725 #else
8726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8727 #endif
8728 }
8729 {
8730 if (temp2)
8731 delete arg2;
8732 }
8733 return resultobj;
8734 fail:
8735 {
8736 if (temp2)
8737 delete arg2;
8738 }
8739 return NULL;
8740 }
8741
8742
8743 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8744 PyObject *obj;
8745 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8746 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8747 Py_INCREF(obj);
8748 return Py_BuildValue((char *)"");
8749 }
8750 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj;
8752 wxFileSystem *result;
8753 char *kwnames[] = {
8754 NULL
8755 };
8756
8757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 result = (wxFileSystem *)new wxFileSystem();
8761
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 {
8766 resultobj = wxPyMake_wxObject(result, 1);
8767 }
8768 return resultobj;
8769 fail:
8770 return NULL;
8771 }
8772
8773
8774 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8775 PyObject *resultobj;
8776 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8777 PyObject * obj0 = 0 ;
8778 char *kwnames[] = {
8779 (char *) "self", NULL
8780 };
8781
8782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8784 if (SWIG_arg_fail(1)) SWIG_fail;
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 delete arg1;
8788
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 Py_INCREF(Py_None); resultobj = Py_None;
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8800 PyObject *resultobj;
8801 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8802 wxString *arg2 = 0 ;
8803 bool arg3 = (bool) false ;
8804 bool temp2 = false ;
8805 PyObject * obj0 = 0 ;
8806 PyObject * obj1 = 0 ;
8807 PyObject * obj2 = 0 ;
8808 char *kwnames[] = {
8809 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8810 };
8811
8812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8814 if (SWIG_arg_fail(1)) SWIG_fail;
8815 {
8816 arg2 = wxString_in_helper(obj1);
8817 if (arg2 == NULL) SWIG_fail;
8818 temp2 = true;
8819 }
8820 if (obj2) {
8821 {
8822 arg3 = (bool)(SWIG_As_bool(obj2));
8823 if (SWIG_arg_fail(3)) SWIG_fail;
8824 }
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8829
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 Py_INCREF(Py_None); resultobj = Py_None;
8834 {
8835 if (temp2)
8836 delete arg2;
8837 }
8838 return resultobj;
8839 fail:
8840 {
8841 if (temp2)
8842 delete arg2;
8843 }
8844 return NULL;
8845 }
8846
8847
8848 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj;
8850 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8851 wxString result;
8852 PyObject * obj0 = 0 ;
8853 char *kwnames[] = {
8854 (char *) "self", NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8859 if (SWIG_arg_fail(1)) SWIG_fail;
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = (arg1)->GetPath();
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 #if wxUSE_UNICODE
8869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8870 #else
8871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8872 #endif
8873 }
8874 return resultobj;
8875 fail:
8876 return NULL;
8877 }
8878
8879
8880 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj;
8882 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8883 wxString *arg2 = 0 ;
8884 wxFSFile *result;
8885 bool temp2 = false ;
8886 PyObject * obj0 = 0 ;
8887 PyObject * obj1 = 0 ;
8888 char *kwnames[] = {
8889 (char *) "self",(char *) "location", NULL
8890 };
8891
8892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8894 if (SWIG_arg_fail(1)) SWIG_fail;
8895 {
8896 arg2 = wxString_in_helper(obj1);
8897 if (arg2 == NULL) SWIG_fail;
8898 temp2 = true;
8899 }
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 resultobj = wxPyMake_wxObject(result, 1);
8909 }
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return resultobj;
8915 fail:
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8927 wxString *arg2 = 0 ;
8928 int arg3 = (int) 0 ;
8929 wxString result;
8930 bool temp2 = false ;
8931 PyObject * obj0 = 0 ;
8932 PyObject * obj1 = 0 ;
8933 PyObject * obj2 = 0 ;
8934 char *kwnames[] = {
8935 (char *) "self",(char *) "spec",(char *) "flags", NULL
8936 };
8937
8938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8940 if (SWIG_arg_fail(1)) SWIG_fail;
8941 {
8942 arg2 = wxString_in_helper(obj1);
8943 if (arg2 == NULL) SWIG_fail;
8944 temp2 = true;
8945 }
8946 if (obj2) {
8947 {
8948 arg3 = (int)(SWIG_As_int(obj2));
8949 if (SWIG_arg_fail(3)) SWIG_fail;
8950 }
8951 }
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 #if wxUSE_UNICODE
8961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8962 #else
8963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8964 #endif
8965 }
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return resultobj;
8971 fail:
8972 {
8973 if (temp2)
8974 delete arg2;
8975 }
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8983 wxString result;
8984 PyObject * obj0 = 0 ;
8985 char *kwnames[] = {
8986 (char *) "self", NULL
8987 };
8988
8989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8991 if (SWIG_arg_fail(1)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (arg1)->FindNext();
8995
8996 wxPyEndAllowThreads(__tstate);
8997 if (PyErr_Occurred()) SWIG_fail;
8998 }
8999 {
9000 #if wxUSE_UNICODE
9001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9002 #else
9003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9004 #endif
9005 }
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9013 PyObject *resultobj;
9014 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9015 PyObject * obj0 = 0 ;
9016 char *kwnames[] = {
9017 (char *) "handler", NULL
9018 };
9019
9020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9022 if (SWIG_arg_fail(1)) SWIG_fail;
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 wxFileSystem::AddHandler(arg1);
9026
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 Py_INCREF(Py_None); resultobj = Py_None;
9031 return resultobj;
9032 fail:
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj;
9039 char *kwnames[] = {
9040 NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 wxFileSystem::CleanUpHandlers();
9047
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 Py_INCREF(Py_None); resultobj = Py_None;
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj;
9060 wxString *arg1 = 0 ;
9061 wxString result;
9062 bool temp1 = false ;
9063 PyObject * obj0 = 0 ;
9064 char *kwnames[] = {
9065 (char *) "filename", NULL
9066 };
9067
9068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9069 {
9070 arg1 = wxString_in_helper(obj0);
9071 if (arg1 == NULL) SWIG_fail;
9072 temp1 = true;
9073 }
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 {
9082 #if wxUSE_UNICODE
9083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9084 #else
9085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9086 #endif
9087 }
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return resultobj;
9093 fail:
9094 {
9095 if (temp1)
9096 delete arg1;
9097 }
9098 return NULL;
9099 }
9100
9101
9102 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9103 PyObject *resultobj;
9104 wxString *arg1 = 0 ;
9105 wxString result;
9106 bool temp1 = false ;
9107 PyObject * obj0 = 0 ;
9108 char *kwnames[] = {
9109 (char *) "url", NULL
9110 };
9111
9112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9113 {
9114 arg1 = wxString_in_helper(obj0);
9115 if (arg1 == NULL) SWIG_fail;
9116 temp1 = true;
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = FileSystem_URLToFileName((wxString const &)*arg1);
9121
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 {
9126 #if wxUSE_UNICODE
9127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9128 #else
9129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9130 #endif
9131 }
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return resultobj;
9137 fail:
9138 {
9139 if (temp1)
9140 delete arg1;
9141 }
9142 return NULL;
9143 }
9144
9145
9146 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9147 PyObject *obj;
9148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9149 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9150 Py_INCREF(obj);
9151 return Py_BuildValue((char *)"");
9152 }
9153 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxInternetFSHandler *result;
9156 char *kwnames[] = {
9157 NULL
9158 };
9159
9160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9164
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9169 return resultobj;
9170 fail:
9171 return NULL;
9172 }
9173
9174
9175 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9176 PyObject *resultobj;
9177 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9178 wxString *arg2 = 0 ;
9179 bool result;
9180 bool temp2 = false ;
9181 PyObject * obj0 = 0 ;
9182 PyObject * obj1 = 0 ;
9183 char *kwnames[] = {
9184 (char *) "self",(char *) "location", NULL
9185 };
9186
9187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9189 if (SWIG_arg_fail(1)) SWIG_fail;
9190 {
9191 arg2 = wxString_in_helper(obj1);
9192 if (arg2 == NULL) SWIG_fail;
9193 temp2 = true;
9194 }
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9198
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 {
9203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9204 }
9205 {
9206 if (temp2)
9207 delete arg2;
9208 }
9209 return resultobj;
9210 fail:
9211 {
9212 if (temp2)
9213 delete arg2;
9214 }
9215 return NULL;
9216 }
9217
9218
9219 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9220 PyObject *resultobj;
9221 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9222 wxFileSystem *arg2 = 0 ;
9223 wxString *arg3 = 0 ;
9224 wxFSFile *result;
9225 bool temp3 = false ;
9226 PyObject * obj0 = 0 ;
9227 PyObject * obj1 = 0 ;
9228 PyObject * obj2 = 0 ;
9229 char *kwnames[] = {
9230 (char *) "self",(char *) "fs",(char *) "location", NULL
9231 };
9232
9233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9235 if (SWIG_arg_fail(1)) SWIG_fail;
9236 {
9237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9238 if (SWIG_arg_fail(2)) SWIG_fail;
9239 if (arg2 == NULL) {
9240 SWIG_null_ref("wxFileSystem");
9241 }
9242 if (SWIG_arg_fail(2)) SWIG_fail;
9243 }
9244 {
9245 arg3 = wxString_in_helper(obj2);
9246 if (arg3 == NULL) SWIG_fail;
9247 temp3 = true;
9248 }
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9252
9253 wxPyEndAllowThreads(__tstate);
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 {
9257 resultobj = wxPyMake_wxObject(result, 1);
9258 }
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return resultobj;
9264 fail:
9265 {
9266 if (temp3)
9267 delete arg3;
9268 }
9269 return NULL;
9270 }
9271
9272
9273 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9274 PyObject *obj;
9275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9276 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9277 Py_INCREF(obj);
9278 return Py_BuildValue((char *)"");
9279 }
9280 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxZipFSHandler *result;
9283 char *kwnames[] = {
9284 NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (wxZipFSHandler *)new wxZipFSHandler();
9291
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9303 PyObject *resultobj;
9304 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9305 wxString *arg2 = 0 ;
9306 bool result;
9307 bool temp2 = false ;
9308 PyObject * obj0 = 0 ;
9309 PyObject * obj1 = 0 ;
9310 char *kwnames[] = {
9311 (char *) "self",(char *) "location", NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9316 if (SWIG_arg_fail(1)) SWIG_fail;
9317 {
9318 arg2 = wxString_in_helper(obj1);
9319 if (arg2 == NULL) SWIG_fail;
9320 temp2 = true;
9321 }
9322 {
9323 PyThreadState* __tstate = wxPyBeginAllowThreads();
9324 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9325
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 {
9330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9331 }
9332 {
9333 if (temp2)
9334 delete arg2;
9335 }
9336 return resultobj;
9337 fail:
9338 {
9339 if (temp2)
9340 delete arg2;
9341 }
9342 return NULL;
9343 }
9344
9345
9346 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9347 PyObject *resultobj;
9348 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9349 wxFileSystem *arg2 = 0 ;
9350 wxString *arg3 = 0 ;
9351 wxFSFile *result;
9352 bool temp3 = false ;
9353 PyObject * obj0 = 0 ;
9354 PyObject * obj1 = 0 ;
9355 PyObject * obj2 = 0 ;
9356 char *kwnames[] = {
9357 (char *) "self",(char *) "fs",(char *) "location", NULL
9358 };
9359
9360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9362 if (SWIG_arg_fail(1)) SWIG_fail;
9363 {
9364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9365 if (SWIG_arg_fail(2)) SWIG_fail;
9366 if (arg2 == NULL) {
9367 SWIG_null_ref("wxFileSystem");
9368 }
9369 if (SWIG_arg_fail(2)) SWIG_fail;
9370 }
9371 {
9372 arg3 = wxString_in_helper(obj2);
9373 if (arg3 == NULL) SWIG_fail;
9374 temp3 = true;
9375 }
9376 {
9377 PyThreadState* __tstate = wxPyBeginAllowThreads();
9378 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9379
9380 wxPyEndAllowThreads(__tstate);
9381 if (PyErr_Occurred()) SWIG_fail;
9382 }
9383 {
9384 resultobj = wxPyMake_wxObject(result, 1);
9385 }
9386 {
9387 if (temp3)
9388 delete arg3;
9389 }
9390 return resultobj;
9391 fail:
9392 {
9393 if (temp3)
9394 delete arg3;
9395 }
9396 return NULL;
9397 }
9398
9399
9400 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9401 PyObject *resultobj;
9402 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9403 wxString *arg2 = 0 ;
9404 int arg3 = (int) 0 ;
9405 wxString result;
9406 bool temp2 = false ;
9407 PyObject * obj0 = 0 ;
9408 PyObject * obj1 = 0 ;
9409 PyObject * obj2 = 0 ;
9410 char *kwnames[] = {
9411 (char *) "self",(char *) "spec",(char *) "flags", NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9416 if (SWIG_arg_fail(1)) SWIG_fail;
9417 {
9418 arg2 = wxString_in_helper(obj1);
9419 if (arg2 == NULL) SWIG_fail;
9420 temp2 = true;
9421 }
9422 if (obj2) {
9423 {
9424 arg3 = (int)(SWIG_As_int(obj2));
9425 if (SWIG_arg_fail(3)) SWIG_fail;
9426 }
9427 }
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9431
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 {
9436 #if wxUSE_UNICODE
9437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9438 #else
9439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9440 #endif
9441 }
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return resultobj;
9447 fail:
9448 {
9449 if (temp2)
9450 delete arg2;
9451 }
9452 return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9459 wxString result;
9460 PyObject * obj0 = 0 ;
9461 char *kwnames[] = {
9462 (char *) "self", NULL
9463 };
9464
9465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9467 if (SWIG_arg_fail(1)) SWIG_fail;
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 result = (arg1)->FindNext();
9471
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 {
9476 #if wxUSE_UNICODE
9477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9478 #else
9479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9480 #endif
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9489 PyObject *obj;
9490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9491 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9492 Py_INCREF(obj);
9493 return Py_BuildValue((char *)"");
9494 }
9495 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxString *arg1 = 0 ;
9498 wxImage *arg2 = 0 ;
9499 long arg3 ;
9500 bool temp1 = false ;
9501 PyObject * obj0 = 0 ;
9502 PyObject * obj1 = 0 ;
9503 PyObject * obj2 = 0 ;
9504 char *kwnames[] = {
9505 (char *) "filename",(char *) "image",(char *) "type", NULL
9506 };
9507
9508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9509 {
9510 arg1 = wxString_in_helper(obj0);
9511 if (arg1 == NULL) SWIG_fail;
9512 temp1 = true;
9513 }
9514 {
9515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9516 if (SWIG_arg_fail(2)) SWIG_fail;
9517 if (arg2 == NULL) {
9518 SWIG_null_ref("wxImage");
9519 }
9520 if (SWIG_arg_fail(2)) SWIG_fail;
9521 }
9522 {
9523 arg3 = (long)(SWIG_As_long(obj2));
9524 if (SWIG_arg_fail(3)) SWIG_fail;
9525 }
9526 {
9527 PyThreadState* __tstate = wxPyBeginAllowThreads();
9528 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9529
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 Py_INCREF(Py_None); resultobj = Py_None;
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return resultobj;
9539 fail:
9540 {
9541 if (temp1)
9542 delete arg1;
9543 }
9544 return NULL;
9545 }
9546
9547
9548 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9549 PyObject *resultobj;
9550 wxString *arg1 = 0 ;
9551 wxBitmap *arg2 = 0 ;
9552 long arg3 ;
9553 bool temp1 = false ;
9554 PyObject * obj0 = 0 ;
9555 PyObject * obj1 = 0 ;
9556 PyObject * obj2 = 0 ;
9557 char *kwnames[] = {
9558 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9559 };
9560
9561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9562 {
9563 arg1 = wxString_in_helper(obj0);
9564 if (arg1 == NULL) SWIG_fail;
9565 temp1 = true;
9566 }
9567 {
9568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9569 if (SWIG_arg_fail(2)) SWIG_fail;
9570 if (arg2 == NULL) {
9571 SWIG_null_ref("wxBitmap");
9572 }
9573 if (SWIG_arg_fail(2)) SWIG_fail;
9574 }
9575 {
9576 arg3 = (long)(SWIG_As_long(obj2));
9577 if (SWIG_arg_fail(3)) SWIG_fail;
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 Py_INCREF(Py_None); resultobj = Py_None;
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return resultobj;
9592 fail:
9593 {
9594 if (temp1)
9595 delete arg1;
9596 }
9597 return NULL;
9598 }
9599
9600
9601 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9602 PyObject *resultobj;
9603 wxString *arg1 = 0 ;
9604 PyObject *arg2 = (PyObject *) 0 ;
9605 bool temp1 = false ;
9606 PyObject * obj0 = 0 ;
9607 PyObject * obj1 = 0 ;
9608 char *kwnames[] = {
9609 (char *) "filename",(char *) "data", NULL
9610 };
9611
9612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9613 {
9614 arg1 = wxString_in_helper(obj0);
9615 if (arg1 == NULL) SWIG_fail;
9616 temp1 = true;
9617 }
9618 arg2 = obj1;
9619 {
9620 PyThreadState* __tstate = wxPyBeginAllowThreads();
9621 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9622
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 Py_INCREF(Py_None); resultobj = Py_None;
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return resultobj;
9632 fail:
9633 {
9634 if (temp1)
9635 delete arg1;
9636 }
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxMemoryFSHandler *result;
9644 char *kwnames[] = {
9645 NULL
9646 };
9647
9648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj;
9665 wxString *arg1 = 0 ;
9666 bool temp1 = false ;
9667 PyObject * obj0 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "filename", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9673 {
9674 arg1 = wxString_in_helper(obj0);
9675 if (arg1 == NULL) SWIG_fail;
9676 temp1 = true;
9677 }
9678 {
9679 PyThreadState* __tstate = wxPyBeginAllowThreads();
9680 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9681
9682 wxPyEndAllowThreads(__tstate);
9683 if (PyErr_Occurred()) SWIG_fail;
9684 }
9685 Py_INCREF(Py_None); resultobj = Py_None;
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return resultobj;
9691 fail:
9692 {
9693 if (temp1)
9694 delete arg1;
9695 }
9696 return NULL;
9697 }
9698
9699
9700 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj;
9702 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9703 wxString *arg2 = 0 ;
9704 bool result;
9705 bool temp2 = false ;
9706 PyObject * obj0 = 0 ;
9707 PyObject * obj1 = 0 ;
9708 char *kwnames[] = {
9709 (char *) "self",(char *) "location", NULL
9710 };
9711
9712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9714 if (SWIG_arg_fail(1)) SWIG_fail;
9715 {
9716 arg2 = wxString_in_helper(obj1);
9717 if (arg2 == NULL) SWIG_fail;
9718 temp2 = true;
9719 }
9720 {
9721 PyThreadState* __tstate = wxPyBeginAllowThreads();
9722 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9723
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 {
9728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9729 }
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return resultobj;
9735 fail:
9736 {
9737 if (temp2)
9738 delete arg2;
9739 }
9740 return NULL;
9741 }
9742
9743
9744 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj;
9746 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9747 wxFileSystem *arg2 = 0 ;
9748 wxString *arg3 = 0 ;
9749 wxFSFile *result;
9750 bool temp3 = false ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 PyObject * obj2 = 0 ;
9754 char *kwnames[] = {
9755 (char *) "self",(char *) "fs",(char *) "location", NULL
9756 };
9757
9758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9760 if (SWIG_arg_fail(1)) SWIG_fail;
9761 {
9762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9763 if (SWIG_arg_fail(2)) SWIG_fail;
9764 if (arg2 == NULL) {
9765 SWIG_null_ref("wxFileSystem");
9766 }
9767 if (SWIG_arg_fail(2)) SWIG_fail;
9768 }
9769 {
9770 arg3 = wxString_in_helper(obj2);
9771 if (arg3 == NULL) SWIG_fail;
9772 temp3 = true;
9773 }
9774 {
9775 PyThreadState* __tstate = wxPyBeginAllowThreads();
9776 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9777
9778 wxPyEndAllowThreads(__tstate);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 {
9782 resultobj = wxPyMake_wxObject(result, 1);
9783 }
9784 {
9785 if (temp3)
9786 delete arg3;
9787 }
9788 return resultobj;
9789 fail:
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9801 wxString *arg2 = 0 ;
9802 int arg3 = (int) 0 ;
9803 wxString result;
9804 bool temp2 = false ;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 PyObject * obj2 = 0 ;
9808 char *kwnames[] = {
9809 (char *) "self",(char *) "spec",(char *) "flags", NULL
9810 };
9811
9812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9814 if (SWIG_arg_fail(1)) SWIG_fail;
9815 {
9816 arg2 = wxString_in_helper(obj1);
9817 if (arg2 == NULL) SWIG_fail;
9818 temp2 = true;
9819 }
9820 if (obj2) {
9821 {
9822 arg3 = (int)(SWIG_As_int(obj2));
9823 if (SWIG_arg_fail(3)) SWIG_fail;
9824 }
9825 }
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 {
9834 #if wxUSE_UNICODE
9835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9836 #else
9837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9838 #endif
9839 }
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return resultobj;
9845 fail:
9846 {
9847 if (temp2)
9848 delete arg2;
9849 }
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9857 wxString result;
9858 PyObject * obj0 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 result = (arg1)->FindNext();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 #if wxUSE_UNICODE
9875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9876 #else
9877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9878 #endif
9879 }
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9887 PyObject *obj;
9888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9889 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9890 Py_INCREF(obj);
9891 return Py_BuildValue((char *)"");
9892 }
9893 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj;
9895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9896 wxString result;
9897 PyObject * obj0 = 0 ;
9898 char *kwnames[] = {
9899 (char *) "self", NULL
9900 };
9901
9902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9904 if (SWIG_arg_fail(1)) SWIG_fail;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 result = (arg1)->GetName();
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 {
9913 #if wxUSE_UNICODE
9914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9915 #else
9916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9917 #endif
9918 }
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9928 wxString result;
9929 PyObject * obj0 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "self", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9936 if (SWIG_arg_fail(1)) SWIG_fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (arg1)->GetExtension();
9940
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 {
9945 #if wxUSE_UNICODE
9946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9947 #else
9948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9949 #endif
9950 }
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9958 PyObject *resultobj;
9959 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9960 long result;
9961 PyObject * obj0 = 0 ;
9962 char *kwnames[] = {
9963 (char *) "self", NULL
9964 };
9965
9966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9968 if (SWIG_arg_fail(1)) SWIG_fail;
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (long)(arg1)->GetType();
9972
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 {
9977 resultobj = SWIG_From_long((long)(result));
9978 }
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj;
9987 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9988 wxString result;
9989 PyObject * obj0 = 0 ;
9990 char *kwnames[] = {
9991 (char *) "self", NULL
9992 };
9993
9994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9996 if (SWIG_arg_fail(1)) SWIG_fail;
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (arg1)->GetMimeType();
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 #if wxUSE_UNICODE
10006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10007 #else
10008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10009 #endif
10010 }
10011 return resultobj;
10012 fail:
10013 return NULL;
10014 }
10015
10016
10017 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10018 PyObject *resultobj;
10019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10020 wxString *arg2 = 0 ;
10021 bool result;
10022 bool temp2 = false ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 char *kwnames[] = {
10026 (char *) "self",(char *) "name", NULL
10027 };
10028
10029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10031 if (SWIG_arg_fail(1)) SWIG_fail;
10032 {
10033 arg2 = wxString_in_helper(obj1);
10034 if (arg2 == NULL) SWIG_fail;
10035 temp2 = true;
10036 }
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10040
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 {
10045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10046 }
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return resultobj;
10052 fail:
10053 {
10054 if (temp2)
10055 delete arg2;
10056 }
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10064 wxString *arg2 = 0 ;
10065 bool temp2 = false ;
10066 PyObject * obj0 = 0 ;
10067 PyObject * obj1 = 0 ;
10068 char *kwnames[] = {
10069 (char *) "self",(char *) "name", NULL
10070 };
10071
10072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10074 if (SWIG_arg_fail(1)) SWIG_fail;
10075 {
10076 arg2 = wxString_in_helper(obj1);
10077 if (arg2 == NULL) SWIG_fail;
10078 temp2 = true;
10079 }
10080 {
10081 PyThreadState* __tstate = wxPyBeginAllowThreads();
10082 (arg1)->SetName((wxString const &)*arg2);
10083
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 Py_INCREF(Py_None); resultobj = Py_None;
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 return resultobj;
10093 fail:
10094 {
10095 if (temp2)
10096 delete arg2;
10097 }
10098 return NULL;
10099 }
10100
10101
10102 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj;
10104 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10105 wxString *arg2 = 0 ;
10106 bool temp2 = false ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char *kwnames[] = {
10110 (char *) "self",(char *) "extension", NULL
10111 };
10112
10113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10115 if (SWIG_arg_fail(1)) SWIG_fail;
10116 {
10117 arg2 = wxString_in_helper(obj1);
10118 if (arg2 == NULL) SWIG_fail;
10119 temp2 = true;
10120 }
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 (arg1)->SetExtension((wxString const &)*arg2);
10124
10125 wxPyEndAllowThreads(__tstate);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 Py_INCREF(Py_None); resultobj = Py_None;
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return resultobj;
10134 fail:
10135 {
10136 if (temp2)
10137 delete arg2;
10138 }
10139 return NULL;
10140 }
10141
10142
10143 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10144 PyObject *resultobj;
10145 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10146 long arg2 ;
10147 PyObject * obj0 = 0 ;
10148 PyObject * obj1 = 0 ;
10149 char *kwnames[] = {
10150 (char *) "self",(char *) "type", NULL
10151 };
10152
10153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10155 if (SWIG_arg_fail(1)) SWIG_fail;
10156 {
10157 arg2 = (long)(SWIG_As_long(obj1));
10158 if (SWIG_arg_fail(2)) SWIG_fail;
10159 }
10160 {
10161 PyThreadState* __tstate = wxPyBeginAllowThreads();
10162 (arg1)->SetType(arg2);
10163
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 Py_INCREF(Py_None); resultobj = Py_None;
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj;
10176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10177 wxString *arg2 = 0 ;
10178 bool temp2 = false ;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 char *kwnames[] = {
10182 (char *) "self",(char *) "mimetype", NULL
10183 };
10184
10185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10187 if (SWIG_arg_fail(1)) SWIG_fail;
10188 {
10189 arg2 = wxString_in_helper(obj1);
10190 if (arg2 == NULL) SWIG_fail;
10191 temp2 = true;
10192 }
10193 {
10194 PyThreadState* __tstate = wxPyBeginAllowThreads();
10195 (arg1)->SetMimeType((wxString const &)*arg2);
10196
10197 wxPyEndAllowThreads(__tstate);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 Py_INCREF(Py_None); resultobj = Py_None;
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return resultobj;
10206 fail:
10207 {
10208 if (temp2)
10209 delete arg2;
10210 }
10211 return NULL;
10212 }
10213
10214
10215 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10216 PyObject *obj;
10217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10218 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10219 Py_INCREF(obj);
10220 return Py_BuildValue((char *)"");
10221 }
10222 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj;
10224 wxImageHistogram *result;
10225 char *kwnames[] = {
10226 NULL
10227 };
10228
10229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (wxImageHistogram *)new wxImageHistogram();
10233
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10238 return resultobj;
10239 fail:
10240 return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj;
10246 byte arg1 ;
10247 byte arg2 ;
10248 byte arg3 ;
10249 unsigned long result;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 PyObject * obj2 = 0 ;
10253 char *kwnames[] = {
10254 (char *) "r",(char *) "g",(char *) "b", NULL
10255 };
10256
10257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10258 {
10259 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10260 if (SWIG_arg_fail(1)) SWIG_fail;
10261 }
10262 {
10263 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10264 if (SWIG_arg_fail(2)) SWIG_fail;
10265 }
10266 {
10267 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10268 if (SWIG_arg_fail(3)) SWIG_fail;
10269 }
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10273
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10279 }
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj;
10288 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10289 byte *arg2 = (byte *) 0 ;
10290 byte *arg3 = (byte *) 0 ;
10291 byte *arg4 = (byte *) 0 ;
10292 byte arg5 = (byte) 1 ;
10293 byte arg6 = (byte) 0 ;
10294 byte arg7 = (byte) 0 ;
10295 bool result;
10296 byte temp2 ;
10297 int res2 = 0 ;
10298 byte temp3 ;
10299 int res3 = 0 ;
10300 byte temp4 ;
10301 int res4 = 0 ;
10302 PyObject * obj0 = 0 ;
10303 PyObject * obj1 = 0 ;
10304 PyObject * obj2 = 0 ;
10305 PyObject * obj3 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10308 };
10309
10310 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10311 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10312 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10315 if (SWIG_arg_fail(1)) SWIG_fail;
10316 if (obj1) {
10317 {
10318 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10319 if (SWIG_arg_fail(5)) SWIG_fail;
10320 }
10321 }
10322 if (obj2) {
10323 {
10324 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10325 if (SWIG_arg_fail(6)) SWIG_fail;
10326 }
10327 }
10328 if (obj3) {
10329 {
10330 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10331 if (SWIG_arg_fail(7)) SWIG_fail;
10332 }
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 {
10342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10343 }
10344 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10345 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10346 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10347 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10348 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10349 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj;
10358 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10359 unsigned long arg2 ;
10360 unsigned long result;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char *kwnames[] = {
10364 (char *) "self",(char *) "key", NULL
10365 };
10366
10367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10369 if (SWIG_arg_fail(1)) SWIG_fail;
10370 {
10371 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10372 if (SWIG_arg_fail(2)) SWIG_fail;
10373 }
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10377
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 {
10382 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10383 }
10384 return resultobj;
10385 fail:
10386 return NULL;
10387 }
10388
10389
10390 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10391 PyObject *resultobj;
10392 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10393 byte arg2 ;
10394 byte arg3 ;
10395 byte arg4 ;
10396 unsigned long result;
10397 PyObject * obj0 = 0 ;
10398 PyObject * obj1 = 0 ;
10399 PyObject * obj2 = 0 ;
10400 PyObject * obj3 = 0 ;
10401 char *kwnames[] = {
10402 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10403 };
10404
10405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10407 if (SWIG_arg_fail(1)) SWIG_fail;
10408 {
10409 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10410 if (SWIG_arg_fail(2)) SWIG_fail;
10411 }
10412 {
10413 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10414 if (SWIG_arg_fail(3)) SWIG_fail;
10415 }
10416 {
10417 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10418 if (SWIG_arg_fail(4)) SWIG_fail;
10419 }
10420 {
10421 PyThreadState* __tstate = wxPyBeginAllowThreads();
10422 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10423
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 {
10428 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10429 }
10430 return resultobj;
10431 fail:
10432 return NULL;
10433 }
10434
10435
10436 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10437 PyObject *resultobj;
10438 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10439 wxColour *arg2 = 0 ;
10440 unsigned long result;
10441 wxColour temp2 ;
10442 PyObject * obj0 = 0 ;
10443 PyObject * obj1 = 0 ;
10444 char *kwnames[] = {
10445 (char *) "self",(char *) "colour", NULL
10446 };
10447
10448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10450 if (SWIG_arg_fail(1)) SWIG_fail;
10451 {
10452 arg2 = &temp2;
10453 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10454 }
10455 {
10456 PyThreadState* __tstate = wxPyBeginAllowThreads();
10457 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10458
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 {
10463 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10464 }
10465 return resultobj;
10466 fail:
10467 return NULL;
10468 }
10469
10470
10471 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10472 PyObject *obj;
10473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10474 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10475 Py_INCREF(obj);
10476 return Py_BuildValue((char *)"");
10477 }
10478 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10479 PyObject *resultobj;
10480 wxString *arg1 = 0 ;
10481 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10482 int arg3 = (int) -1 ;
10483 wxImage *result;
10484 bool temp1 = false ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 PyObject * obj2 = 0 ;
10488 char *kwnames[] = {
10489 (char *) "name",(char *) "type",(char *) "index", NULL
10490 };
10491
10492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10493 {
10494 arg1 = wxString_in_helper(obj0);
10495 if (arg1 == NULL) SWIG_fail;
10496 temp1 = true;
10497 }
10498 if (obj1) {
10499 {
10500 arg2 = (long)(SWIG_As_long(obj1));
10501 if (SWIG_arg_fail(2)) SWIG_fail;
10502 }
10503 }
10504 if (obj2) {
10505 {
10506 arg3 = (int)(SWIG_As_int(obj2));
10507 if (SWIG_arg_fail(3)) SWIG_fail;
10508 }
10509 }
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10513
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 return resultobj;
10523 fail:
10524 {
10525 if (temp1)
10526 delete arg1;
10527 }
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxImage *arg1 = (wxImage *) 0 ;
10535 PyObject * obj0 = 0 ;
10536 char *kwnames[] = {
10537 (char *) "self", NULL
10538 };
10539
10540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10542 if (SWIG_arg_fail(1)) SWIG_fail;
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 delete arg1;
10546
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 Py_INCREF(Py_None); resultobj = Py_None;
10551 return resultobj;
10552 fail:
10553 return NULL;
10554 }
10555
10556
10557 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10558 PyObject *resultobj;
10559 wxString *arg1 = 0 ;
10560 wxString *arg2 = 0 ;
10561 int arg3 = (int) -1 ;
10562 wxImage *result;
10563 bool temp1 = false ;
10564 bool temp2 = false ;
10565 PyObject * obj0 = 0 ;
10566 PyObject * obj1 = 0 ;
10567 PyObject * obj2 = 0 ;
10568 char *kwnames[] = {
10569 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10570 };
10571
10572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10573 {
10574 arg1 = wxString_in_helper(obj0);
10575 if (arg1 == NULL) SWIG_fail;
10576 temp1 = true;
10577 }
10578 {
10579 arg2 = wxString_in_helper(obj1);
10580 if (arg2 == NULL) SWIG_fail;
10581 temp2 = true;
10582 }
10583 if (obj2) {
10584 {
10585 arg3 = (int)(SWIG_As_int(obj2));
10586 if (SWIG_arg_fail(3)) SWIG_fail;
10587 }
10588 }
10589 {
10590 PyThreadState* __tstate = wxPyBeginAllowThreads();
10591 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10592
10593 wxPyEndAllowThreads(__tstate);
10594 if (PyErr_Occurred()) SWIG_fail;
10595 }
10596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10597 {
10598 if (temp1)
10599 delete arg1;
10600 }
10601 {
10602 if (temp2)
10603 delete arg2;
10604 }
10605 return resultobj;
10606 fail:
10607 {
10608 if (temp1)
10609 delete arg1;
10610 }
10611 {
10612 if (temp2)
10613 delete arg2;
10614 }
10615 return NULL;
10616 }
10617
10618
10619 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxInputStream *arg1 = 0 ;
10622 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10623 int arg3 = (int) -1 ;
10624 wxImage *result;
10625 wxPyInputStream *temp1 ;
10626 bool created1 ;
10627 PyObject * obj0 = 0 ;
10628 PyObject * obj1 = 0 ;
10629 PyObject * obj2 = 0 ;
10630 char *kwnames[] = {
10631 (char *) "stream",(char *) "type",(char *) "index", NULL
10632 };
10633
10634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10635 {
10636 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10637 arg1 = temp1->m_wxis;
10638 created1 = false;
10639 } else {
10640 PyErr_Clear(); // clear the failure of the wxPyConvert above
10641 arg1 = wxPyCBInputStream_create(obj0, false);
10642 if (arg1 == NULL) {
10643 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10644 SWIG_fail;
10645 }
10646 created1 = true;
10647 }
10648 }
10649 if (obj1) {
10650 {
10651 arg2 = (long)(SWIG_As_long(obj1));
10652 if (SWIG_arg_fail(2)) SWIG_fail;
10653 }
10654 }
10655 if (obj2) {
10656 {
10657 arg3 = (int)(SWIG_As_int(obj2));
10658 if (SWIG_arg_fail(3)) SWIG_fail;
10659 }
10660 }
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10664
10665 wxPyEndAllowThreads(__tstate);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10669 {
10670 if (created1) delete arg1;
10671 }
10672 return resultobj;
10673 fail:
10674 {
10675 if (created1) delete arg1;
10676 }
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxInputStream *arg1 = 0 ;
10684 wxString *arg2 = 0 ;
10685 int arg3 = (int) -1 ;
10686 wxImage *result;
10687 wxPyInputStream *temp1 ;
10688 bool created1 ;
10689 bool temp2 = false ;
10690 PyObject * obj0 = 0 ;
10691 PyObject * obj1 = 0 ;
10692 PyObject * obj2 = 0 ;
10693 char *kwnames[] = {
10694 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10695 };
10696
10697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10698 {
10699 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10700 arg1 = temp1->m_wxis;
10701 created1 = false;
10702 } else {
10703 PyErr_Clear(); // clear the failure of the wxPyConvert above
10704 arg1 = wxPyCBInputStream_create(obj0, false);
10705 if (arg1 == NULL) {
10706 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10707 SWIG_fail;
10708 }
10709 created1 = true;
10710 }
10711 }
10712 {
10713 arg2 = wxString_in_helper(obj1);
10714 if (arg2 == NULL) SWIG_fail;
10715 temp2 = true;
10716 }
10717 if (obj2) {
10718 {
10719 arg3 = (int)(SWIG_As_int(obj2));
10720 if (SWIG_arg_fail(3)) SWIG_fail;
10721 }
10722 }
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10726
10727 wxPyEndAllowThreads(__tstate);
10728 if (PyErr_Occurred()) SWIG_fail;
10729 }
10730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10731 {
10732 if (created1) delete arg1;
10733 }
10734 {
10735 if (temp2)
10736 delete arg2;
10737 }
10738 return resultobj;
10739 fail:
10740 {
10741 if (created1) delete arg1;
10742 }
10743 {
10744 if (temp2)
10745 delete arg2;
10746 }
10747 return NULL;
10748 }
10749
10750
10751 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj;
10753 int arg1 = (int) 0 ;
10754 int arg2 = (int) 0 ;
10755 bool arg3 = (bool) true ;
10756 wxImage *result;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 PyObject * obj2 = 0 ;
10760 char *kwnames[] = {
10761 (char *) "width",(char *) "height",(char *) "clear", NULL
10762 };
10763
10764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10765 if (obj0) {
10766 {
10767 arg1 = (int)(SWIG_As_int(obj0));
10768 if (SWIG_arg_fail(1)) SWIG_fail;
10769 }
10770 }
10771 if (obj1) {
10772 {
10773 arg2 = (int)(SWIG_As_int(obj1));
10774 if (SWIG_arg_fail(2)) SWIG_fail;
10775 }
10776 }
10777 if (obj2) {
10778 {
10779 arg3 = (bool)(SWIG_As_bool(obj2));
10780 if (SWIG_arg_fail(3)) SWIG_fail;
10781 }
10782 }
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10786
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10791 return resultobj;
10792 fail:
10793 return NULL;
10794 }
10795
10796
10797 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10798 PyObject *resultobj;
10799 wxBitmap *arg1 = 0 ;
10800 wxImage *result;
10801 PyObject * obj0 = 0 ;
10802 char *kwnames[] = {
10803 (char *) "bitmap", NULL
10804 };
10805
10806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10807 {
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 if (arg1 == NULL) {
10811 SWIG_null_ref("wxBitmap");
10812 }
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 }
10815 {
10816 if (!wxPyCheckForApp()) SWIG_fail;
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10831 PyObject *resultobj;
10832 int arg1 ;
10833 int arg2 ;
10834 buffer arg3 ;
10835 int arg4 ;
10836 wxImage *result;
10837 PyObject * obj0 = 0 ;
10838 PyObject * obj1 = 0 ;
10839 PyObject * obj2 = 0 ;
10840 char *kwnames[] = {
10841 (char *) "width",(char *) "height",(char *) "data", NULL
10842 };
10843
10844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10845 {
10846 arg1 = (int)(SWIG_As_int(obj0));
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 }
10849 {
10850 arg2 = (int)(SWIG_As_int(obj1));
10851 if (SWIG_arg_fail(2)) SWIG_fail;
10852 }
10853 {
10854 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10855 }
10856 {
10857 PyThreadState* __tstate = wxPyBeginAllowThreads();
10858 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10859
10860 wxPyEndAllowThreads(__tstate);
10861 if (PyErr_Occurred()) SWIG_fail;
10862 }
10863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj;
10872 int arg1 ;
10873 int arg2 ;
10874 buffer arg3 ;
10875 int arg4 ;
10876 buffer arg5 ;
10877 int arg6 ;
10878 wxImage *result;
10879 PyObject * obj0 = 0 ;
10880 PyObject * obj1 = 0 ;
10881 PyObject * obj2 = 0 ;
10882 PyObject * obj3 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10888 {
10889 arg1 = (int)(SWIG_As_int(obj0));
10890 if (SWIG_arg_fail(1)) SWIG_fail;
10891 }
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10898 }
10899 {
10900 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10901 }
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10905
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj;
10918 wxImage *arg1 = (wxImage *) 0 ;
10919 int arg2 ;
10920 int arg3 ;
10921 bool arg4 = (bool) true ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 PyObject * obj2 = 0 ;
10925 PyObject * obj3 = 0 ;
10926 char *kwnames[] = {
10927 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10928 };
10929
10930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10932 if (SWIG_arg_fail(1)) SWIG_fail;
10933 {
10934 arg2 = (int)(SWIG_As_int(obj1));
10935 if (SWIG_arg_fail(2)) SWIG_fail;
10936 }
10937 {
10938 arg3 = (int)(SWIG_As_int(obj2));
10939 if (SWIG_arg_fail(3)) SWIG_fail;
10940 }
10941 if (obj3) {
10942 {
10943 arg4 = (bool)(SWIG_As_bool(obj3));
10944 if (SWIG_arg_fail(4)) SWIG_fail;
10945 }
10946 }
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 (arg1)->Create(arg2,arg3,arg4);
10950
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 Py_INCREF(Py_None); resultobj = Py_None;
10955 return resultobj;
10956 fail:
10957 return NULL;
10958 }
10959
10960
10961 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10962 PyObject *resultobj;
10963 wxImage *arg1 = (wxImage *) 0 ;
10964 PyObject * obj0 = 0 ;
10965 char *kwnames[] = {
10966 (char *) "self", NULL
10967 };
10968
10969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10971 if (SWIG_arg_fail(1)) SWIG_fail;
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 (arg1)->Destroy();
10975
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 Py_INCREF(Py_None); resultobj = Py_None;
10980 return resultobj;
10981 fail:
10982 return NULL;
10983 }
10984
10985
10986 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10987 PyObject *resultobj;
10988 wxImage *arg1 = (wxImage *) 0 ;
10989 int arg2 ;
10990 int arg3 ;
10991 SwigValueWrapper<wxImage > result;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 PyObject * obj2 = 0 ;
10995 char *kwnames[] = {
10996 (char *) "self",(char *) "width",(char *) "height", NULL
10997 };
10998
10999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11001 if (SWIG_arg_fail(1)) SWIG_fail;
11002 {
11003 arg2 = (int)(SWIG_As_int(obj1));
11004 if (SWIG_arg_fail(2)) SWIG_fail;
11005 }
11006 {
11007 arg3 = (int)(SWIG_As_int(obj2));
11008 if (SWIG_arg_fail(3)) SWIG_fail;
11009 }
11010 {
11011 PyThreadState* __tstate = wxPyBeginAllowThreads();
11012 result = (arg1)->Scale(arg2,arg3);
11013
11014 wxPyEndAllowThreads(__tstate);
11015 if (PyErr_Occurred()) SWIG_fail;
11016 }
11017 {
11018 wxImage * resultptr;
11019 resultptr = new wxImage((wxImage &)(result));
11020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11021 }
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj;
11030 wxImage *arg1 = (wxImage *) 0 ;
11031 int arg2 ;
11032 int arg3 ;
11033 SwigValueWrapper<wxImage > result;
11034 PyObject * obj0 = 0 ;
11035 PyObject * obj1 = 0 ;
11036 PyObject * obj2 = 0 ;
11037 char *kwnames[] = {
11038 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11039 };
11040
11041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11043 if (SWIG_arg_fail(1)) SWIG_fail;
11044 {
11045 arg2 = (int)(SWIG_As_int(obj1));
11046 if (SWIG_arg_fail(2)) SWIG_fail;
11047 }
11048 {
11049 arg3 = (int)(SWIG_As_int(obj2));
11050 if (SWIG_arg_fail(3)) SWIG_fail;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 {
11060 wxImage * resultptr;
11061 resultptr = new wxImage((wxImage &)(result));
11062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11063 }
11064 return resultobj;
11065 fail:
11066 return NULL;
11067 }
11068
11069
11070 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11071 PyObject *resultobj;
11072 wxImage *arg1 = (wxImage *) 0 ;
11073 int arg2 ;
11074 int arg3 ;
11075 wxImage *result;
11076 PyObject * obj0 = 0 ;
11077 PyObject * obj1 = 0 ;
11078 PyObject * obj2 = 0 ;
11079 char *kwnames[] = {
11080 (char *) "self",(char *) "width",(char *) "height", NULL
11081 };
11082
11083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11085 if (SWIG_arg_fail(1)) SWIG_fail;
11086 {
11087 arg2 = (int)(SWIG_As_int(obj1));
11088 if (SWIG_arg_fail(2)) SWIG_fail;
11089 }
11090 {
11091 arg3 = (int)(SWIG_As_int(obj2));
11092 if (SWIG_arg_fail(3)) SWIG_fail;
11093 }
11094 {
11095 PyThreadState* __tstate = wxPyBeginAllowThreads();
11096 {
11097 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11098 result = (wxImage *) &_result_ref;
11099 }
11100
11101 wxPyEndAllowThreads(__tstate);
11102 if (PyErr_Occurred()) SWIG_fail;
11103 }
11104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj;
11113 wxImage *arg1 = (wxImage *) 0 ;
11114 wxSize *arg2 = 0 ;
11115 wxPoint *arg3 = 0 ;
11116 int arg4 = (int) -1 ;
11117 int arg5 = (int) -1 ;
11118 int arg6 = (int) -1 ;
11119 wxImage *result;
11120 wxSize temp2 ;
11121 wxPoint temp3 ;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 PyObject * obj3 = 0 ;
11126 PyObject * obj4 = 0 ;
11127 PyObject * obj5 = 0 ;
11128 char *kwnames[] = {
11129 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11130 };
11131
11132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11134 if (SWIG_arg_fail(1)) SWIG_fail;
11135 {
11136 arg2 = &temp2;
11137 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11138 }
11139 {
11140 arg3 = &temp3;
11141 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11142 }
11143 if (obj3) {
11144 {
11145 arg4 = (int)(SWIG_As_int(obj3));
11146 if (SWIG_arg_fail(4)) SWIG_fail;
11147 }
11148 }
11149 if (obj4) {
11150 {
11151 arg5 = (int)(SWIG_As_int(obj4));
11152 if (SWIG_arg_fail(5)) SWIG_fail;
11153 }
11154 }
11155 if (obj5) {
11156 {
11157 arg6 = (int)(SWIG_As_int(obj5));
11158 if (SWIG_arg_fail(6)) SWIG_fail;
11159 }
11160 }
11161 {
11162 PyThreadState* __tstate = wxPyBeginAllowThreads();
11163 {
11164 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11165 result = (wxImage *) &_result_ref;
11166 }
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11179 PyObject *resultobj;
11180 wxImage *arg1 = (wxImage *) 0 ;
11181 int arg2 ;
11182 int arg3 ;
11183 byte arg4 ;
11184 byte arg5 ;
11185 byte arg6 ;
11186 PyObject * obj0 = 0 ;
11187 PyObject * obj1 = 0 ;
11188 PyObject * obj2 = 0 ;
11189 PyObject * obj3 = 0 ;
11190 PyObject * obj4 = 0 ;
11191 PyObject * obj5 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 {
11200 arg2 = (int)(SWIG_As_int(obj1));
11201 if (SWIG_arg_fail(2)) SWIG_fail;
11202 }
11203 {
11204 arg3 = (int)(SWIG_As_int(obj2));
11205 if (SWIG_arg_fail(3)) SWIG_fail;
11206 }
11207 {
11208 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11209 if (SWIG_arg_fail(4)) SWIG_fail;
11210 }
11211 {
11212 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11213 if (SWIG_arg_fail(5)) SWIG_fail;
11214 }
11215 {
11216 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11217 if (SWIG_arg_fail(6)) SWIG_fail;
11218 }
11219 {
11220 PyThreadState* __tstate = wxPyBeginAllowThreads();
11221 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11222
11223 wxPyEndAllowThreads(__tstate);
11224 if (PyErr_Occurred()) SWIG_fail;
11225 }
11226 Py_INCREF(Py_None); resultobj = Py_None;
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11234 PyObject *resultobj;
11235 wxImage *arg1 = (wxImage *) 0 ;
11236 wxRect *arg2 = 0 ;
11237 byte arg3 ;
11238 byte arg4 ;
11239 byte arg5 ;
11240 wxRect temp2 ;
11241 PyObject * obj0 = 0 ;
11242 PyObject * obj1 = 0 ;
11243 PyObject * obj2 = 0 ;
11244 PyObject * obj3 = 0 ;
11245 PyObject * obj4 = 0 ;
11246 char *kwnames[] = {
11247 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11248 };
11249
11250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11252 if (SWIG_arg_fail(1)) SWIG_fail;
11253 {
11254 arg2 = &temp2;
11255 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11256 }
11257 {
11258 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11259 if (SWIG_arg_fail(3)) SWIG_fail;
11260 }
11261 {
11262 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11263 if (SWIG_arg_fail(4)) SWIG_fail;
11264 }
11265 {
11266 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11267 if (SWIG_arg_fail(5)) SWIG_fail;
11268 }
11269 {
11270 PyThreadState* __tstate = wxPyBeginAllowThreads();
11271 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11272
11273 wxPyEndAllowThreads(__tstate);
11274 if (PyErr_Occurred()) SWIG_fail;
11275 }
11276 Py_INCREF(Py_None); resultobj = Py_None;
11277 return resultobj;
11278 fail:
11279 return NULL;
11280 }
11281
11282
11283 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj;
11285 wxImage *arg1 = (wxImage *) 0 ;
11286 int arg2 ;
11287 int arg3 ;
11288 byte result;
11289 PyObject * obj0 = 0 ;
11290 PyObject * obj1 = 0 ;
11291 PyObject * obj2 = 0 ;
11292 char *kwnames[] = {
11293 (char *) "self",(char *) "x",(char *) "y", NULL
11294 };
11295
11296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11298 if (SWIG_arg_fail(1)) SWIG_fail;
11299 {
11300 arg2 = (int)(SWIG_As_int(obj1));
11301 if (SWIG_arg_fail(2)) SWIG_fail;
11302 }
11303 {
11304 arg3 = (int)(SWIG_As_int(obj2));
11305 if (SWIG_arg_fail(3)) SWIG_fail;
11306 }
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (byte)(arg1)->GetRed(arg2,arg3);
11310
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 {
11315 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11316 }
11317 return resultobj;
11318 fail:
11319 return NULL;
11320 }
11321
11322
11323 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11324 PyObject *resultobj;
11325 wxImage *arg1 = (wxImage *) 0 ;
11326 int arg2 ;
11327 int arg3 ;
11328 byte result;
11329 PyObject * obj0 = 0 ;
11330 PyObject * obj1 = 0 ;
11331 PyObject * obj2 = 0 ;
11332 char *kwnames[] = {
11333 (char *) "self",(char *) "x",(char *) "y", NULL
11334 };
11335
11336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11338 if (SWIG_arg_fail(1)) SWIG_fail;
11339 {
11340 arg2 = (int)(SWIG_As_int(obj1));
11341 if (SWIG_arg_fail(2)) SWIG_fail;
11342 }
11343 {
11344 arg3 = (int)(SWIG_As_int(obj2));
11345 if (SWIG_arg_fail(3)) SWIG_fail;
11346 }
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 result = (byte)(arg1)->GetGreen(arg2,arg3);
11350
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 {
11355 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 wxImage *arg1 = (wxImage *) 0 ;
11366 int arg2 ;
11367 int arg3 ;
11368 byte result;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11371 PyObject * obj2 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self",(char *) "x",(char *) "y", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 {
11380 arg2 = (int)(SWIG_As_int(obj1));
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 {
11384 arg3 = (int)(SWIG_As_int(obj2));
11385 if (SWIG_arg_fail(3)) SWIG_fail;
11386 }
11387 {
11388 PyThreadState* __tstate = wxPyBeginAllowThreads();
11389 result = (byte)(arg1)->GetBlue(arg2,arg3);
11390
11391 wxPyEndAllowThreads(__tstate);
11392 if (PyErr_Occurred()) SWIG_fail;
11393 }
11394 {
11395 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11396 }
11397 return resultobj;
11398 fail:
11399 return NULL;
11400 }
11401
11402
11403 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11404 PyObject *resultobj;
11405 wxImage *arg1 = (wxImage *) 0 ;
11406 int arg2 ;
11407 int arg3 ;
11408 byte arg4 ;
11409 PyObject * obj0 = 0 ;
11410 PyObject * obj1 = 0 ;
11411 PyObject * obj2 = 0 ;
11412 PyObject * obj3 = 0 ;
11413 char *kwnames[] = {
11414 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11415 };
11416
11417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11419 if (SWIG_arg_fail(1)) SWIG_fail;
11420 {
11421 arg2 = (int)(SWIG_As_int(obj1));
11422 if (SWIG_arg_fail(2)) SWIG_fail;
11423 }
11424 {
11425 arg3 = (int)(SWIG_As_int(obj2));
11426 if (SWIG_arg_fail(3)) SWIG_fail;
11427 }
11428 {
11429 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11430 if (SWIG_arg_fail(4)) SWIG_fail;
11431 }
11432 {
11433 PyThreadState* __tstate = wxPyBeginAllowThreads();
11434 (arg1)->SetAlpha(arg2,arg3,arg4);
11435
11436 wxPyEndAllowThreads(__tstate);
11437 if (PyErr_Occurred()) SWIG_fail;
11438 }
11439 Py_INCREF(Py_None); resultobj = Py_None;
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11447 PyObject *resultobj;
11448 wxImage *arg1 = (wxImage *) 0 ;
11449 int arg2 ;
11450 int arg3 ;
11451 byte result;
11452 PyObject * obj0 = 0 ;
11453 PyObject * obj1 = 0 ;
11454 PyObject * obj2 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "self",(char *) "x",(char *) "y", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11461 if (SWIG_arg_fail(1)) SWIG_fail;
11462 {
11463 arg2 = (int)(SWIG_As_int(obj1));
11464 if (SWIG_arg_fail(2)) SWIG_fail;
11465 }
11466 {
11467 arg3 = (int)(SWIG_As_int(obj2));
11468 if (SWIG_arg_fail(3)) SWIG_fail;
11469 }
11470 {
11471 PyThreadState* __tstate = wxPyBeginAllowThreads();
11472 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11473
11474 wxPyEndAllowThreads(__tstate);
11475 if (PyErr_Occurred()) SWIG_fail;
11476 }
11477 {
11478 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11479 }
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj;
11488 wxImage *arg1 = (wxImage *) 0 ;
11489 bool result;
11490 PyObject * obj0 = 0 ;
11491 char *kwnames[] = {
11492 (char *) "self", NULL
11493 };
11494
11495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11497 if (SWIG_arg_fail(1)) SWIG_fail;
11498 {
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = (bool)(arg1)->HasAlpha();
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11507 }
11508 return resultobj;
11509 fail:
11510 return NULL;
11511 }
11512
11513
11514 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj;
11516 wxImage *arg1 = (wxImage *) 0 ;
11517 PyObject * obj0 = 0 ;
11518 char *kwnames[] = {
11519 (char *) "self", NULL
11520 };
11521
11522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11524 if (SWIG_arg_fail(1)) SWIG_fail;
11525 {
11526 PyThreadState* __tstate = wxPyBeginAllowThreads();
11527 (arg1)->InitAlpha();
11528
11529 wxPyEndAllowThreads(__tstate);
11530 if (PyErr_Occurred()) SWIG_fail;
11531 }
11532 Py_INCREF(Py_None); resultobj = Py_None;
11533 return resultobj;
11534 fail:
11535 return NULL;
11536 }
11537
11538
11539 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11540 PyObject *resultobj;
11541 wxImage *arg1 = (wxImage *) 0 ;
11542 int arg2 ;
11543 int arg3 ;
11544 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11545 bool result;
11546 PyObject * obj0 = 0 ;
11547 PyObject * obj1 = 0 ;
11548 PyObject * obj2 = 0 ;
11549 PyObject * obj3 = 0 ;
11550 char *kwnames[] = {
11551 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11552 };
11553
11554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11556 if (SWIG_arg_fail(1)) SWIG_fail;
11557 {
11558 arg2 = (int)(SWIG_As_int(obj1));
11559 if (SWIG_arg_fail(2)) SWIG_fail;
11560 }
11561 {
11562 arg3 = (int)(SWIG_As_int(obj2));
11563 if (SWIG_arg_fail(3)) SWIG_fail;
11564 }
11565 if (obj3) {
11566 {
11567 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11568 if (SWIG_arg_fail(4)) SWIG_fail;
11569 }
11570 }
11571 {
11572 PyThreadState* __tstate = wxPyBeginAllowThreads();
11573 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11574
11575 wxPyEndAllowThreads(__tstate);
11576 if (PyErr_Occurred()) SWIG_fail;
11577 }
11578 {
11579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11580 }
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj;
11589 wxImage *arg1 = (wxImage *) 0 ;
11590 byte *arg2 = (byte *) 0 ;
11591 byte *arg3 = (byte *) 0 ;
11592 byte *arg4 = (byte *) 0 ;
11593 byte arg5 = (byte) 0 ;
11594 byte arg6 = (byte) 0 ;
11595 byte arg7 = (byte) 0 ;
11596 bool result;
11597 byte temp2 ;
11598 int res2 = 0 ;
11599 byte temp3 ;
11600 int res3 = 0 ;
11601 byte temp4 ;
11602 int res4 = 0 ;
11603 PyObject * obj0 = 0 ;
11604 PyObject * obj1 = 0 ;
11605 PyObject * obj2 = 0 ;
11606 PyObject * obj3 = 0 ;
11607 char *kwnames[] = {
11608 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11609 };
11610
11611 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11612 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11613 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11616 if (SWIG_arg_fail(1)) SWIG_fail;
11617 if (obj1) {
11618 {
11619 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11620 if (SWIG_arg_fail(5)) SWIG_fail;
11621 }
11622 }
11623 if (obj2) {
11624 {
11625 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11626 if (SWIG_arg_fail(6)) SWIG_fail;
11627 }
11628 }
11629 if (obj3) {
11630 {
11631 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11632 if (SWIG_arg_fail(7)) SWIG_fail;
11633 }
11634 }
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11638
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11644 }
11645 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11646 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11647 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11648 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11649 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11650 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11651 return resultobj;
11652 fail:
11653 return NULL;
11654 }
11655
11656
11657 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11658 PyObject *resultobj;
11659 wxImage *arg1 = (wxImage *) 0 ;
11660 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11661 bool result;
11662 PyObject * obj0 = 0 ;
11663 PyObject * obj1 = 0 ;
11664 char *kwnames[] = {
11665 (char *) "self",(char *) "threshold", NULL
11666 };
11667
11668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 if (obj1) {
11672 {
11673 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11674 if (SWIG_arg_fail(2)) SWIG_fail;
11675 }
11676 }
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11680
11681 wxPyEndAllowThreads(__tstate);
11682 if (PyErr_Occurred()) SWIG_fail;
11683 }
11684 {
11685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11686 }
11687 return resultobj;
11688 fail:
11689 return NULL;
11690 }
11691
11692
11693 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11694 PyObject *resultobj;
11695 wxImage *arg1 = (wxImage *) 0 ;
11696 byte arg2 ;
11697 byte arg3 ;
11698 byte arg4 ;
11699 bool result;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 PyObject * obj3 = 0 ;
11704 char *kwnames[] = {
11705 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11706 };
11707
11708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11710 if (SWIG_arg_fail(1)) SWIG_fail;
11711 {
11712 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11713 if (SWIG_arg_fail(2)) SWIG_fail;
11714 }
11715 {
11716 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11717 if (SWIG_arg_fail(3)) SWIG_fail;
11718 }
11719 {
11720 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11721 if (SWIG_arg_fail(4)) SWIG_fail;
11722 }
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11726
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11732 }
11733 return resultobj;
11734 fail:
11735 return NULL;
11736 }
11737
11738
11739 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11740 PyObject *resultobj;
11741 wxImage *arg1 = (wxImage *) 0 ;
11742 wxImage *arg2 = 0 ;
11743 byte arg3 ;
11744 byte arg4 ;
11745 byte arg5 ;
11746 bool result;
11747 PyObject * obj0 = 0 ;
11748 PyObject * obj1 = 0 ;
11749 PyObject * obj2 = 0 ;
11750 PyObject * obj3 = 0 ;
11751 PyObject * obj4 = 0 ;
11752 char *kwnames[] = {
11753 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11754 };
11755
11756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11758 if (SWIG_arg_fail(1)) SWIG_fail;
11759 {
11760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11761 if (SWIG_arg_fail(2)) SWIG_fail;
11762 if (arg2 == NULL) {
11763 SWIG_null_ref("wxImage");
11764 }
11765 if (SWIG_arg_fail(2)) SWIG_fail;
11766 }
11767 {
11768 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11769 if (SWIG_arg_fail(3)) SWIG_fail;
11770 }
11771 {
11772 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11773 if (SWIG_arg_fail(4)) SWIG_fail;
11774 }
11775 {
11776 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11777 if (SWIG_arg_fail(5)) SWIG_fail;
11778 }
11779 {
11780 PyThreadState* __tstate = wxPyBeginAllowThreads();
11781 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11782
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 {
11787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11788 }
11789 return resultobj;
11790 fail:
11791 return NULL;
11792 }
11793
11794
11795 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj;
11797 wxString *arg1 = 0 ;
11798 bool result;
11799 bool temp1 = false ;
11800 PyObject * obj0 = 0 ;
11801 char *kwnames[] = {
11802 (char *) "filename", NULL
11803 };
11804
11805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11806 {
11807 arg1 = wxString_in_helper(obj0);
11808 if (arg1 == NULL) SWIG_fail;
11809 temp1 = true;
11810 }
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11814
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11820 }
11821 {
11822 if (temp1)
11823 delete arg1;
11824 }
11825 return resultobj;
11826 fail:
11827 {
11828 if (temp1)
11829 delete arg1;
11830 }
11831 return NULL;
11832 }
11833
11834
11835 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11836 PyObject *resultobj;
11837 wxString *arg1 = 0 ;
11838 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11839 int result;
11840 bool temp1 = false ;
11841 PyObject * obj0 = 0 ;
11842 PyObject * obj1 = 0 ;
11843 char *kwnames[] = {
11844 (char *) "filename",(char *) "type", NULL
11845 };
11846
11847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11848 {
11849 arg1 = wxString_in_helper(obj0);
11850 if (arg1 == NULL) SWIG_fail;
11851 temp1 = true;
11852 }
11853 if (obj1) {
11854 {
11855 arg2 = (long)(SWIG_As_long(obj1));
11856 if (SWIG_arg_fail(2)) SWIG_fail;
11857 }
11858 }
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 {
11867 resultobj = SWIG_From_int((int)(result));
11868 }
11869 {
11870 if (temp1)
11871 delete arg1;
11872 }
11873 return resultobj;
11874 fail:
11875 {
11876 if (temp1)
11877 delete arg1;
11878 }
11879 return NULL;
11880 }
11881
11882
11883 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11884 PyObject *resultobj;
11885 wxImage *arg1 = (wxImage *) 0 ;
11886 wxString *arg2 = 0 ;
11887 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11888 int arg4 = (int) -1 ;
11889 bool result;
11890 bool temp2 = false ;
11891 PyObject * obj0 = 0 ;
11892 PyObject * obj1 = 0 ;
11893 PyObject * obj2 = 0 ;
11894 PyObject * obj3 = 0 ;
11895 char *kwnames[] = {
11896 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11897 };
11898
11899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11901 if (SWIG_arg_fail(1)) SWIG_fail;
11902 {
11903 arg2 = wxString_in_helper(obj1);
11904 if (arg2 == NULL) SWIG_fail;
11905 temp2 = true;
11906 }
11907 if (obj2) {
11908 {
11909 arg3 = (long)(SWIG_As_long(obj2));
11910 if (SWIG_arg_fail(3)) SWIG_fail;
11911 }
11912 }
11913 if (obj3) {
11914 {
11915 arg4 = (int)(SWIG_As_int(obj3));
11916 if (SWIG_arg_fail(4)) SWIG_fail;
11917 }
11918 }
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11922
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 {
11930 if (temp2)
11931 delete arg2;
11932 }
11933 return resultobj;
11934 fail:
11935 {
11936 if (temp2)
11937 delete arg2;
11938 }
11939 return NULL;
11940 }
11941
11942
11943 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj;
11945 wxImage *arg1 = (wxImage *) 0 ;
11946 wxString *arg2 = 0 ;
11947 wxString *arg3 = 0 ;
11948 int arg4 = (int) -1 ;
11949 bool result;
11950 bool temp2 = false ;
11951 bool temp3 = false ;
11952 PyObject * obj0 = 0 ;
11953 PyObject * obj1 = 0 ;
11954 PyObject * obj2 = 0 ;
11955 PyObject * obj3 = 0 ;
11956 char *kwnames[] = {
11957 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11958 };
11959
11960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11962 if (SWIG_arg_fail(1)) SWIG_fail;
11963 {
11964 arg2 = wxString_in_helper(obj1);
11965 if (arg2 == NULL) SWIG_fail;
11966 temp2 = true;
11967 }
11968 {
11969 arg3 = wxString_in_helper(obj2);
11970 if (arg3 == NULL) SWIG_fail;
11971 temp3 = true;
11972 }
11973 if (obj3) {
11974 {
11975 arg4 = (int)(SWIG_As_int(obj3));
11976 if (SWIG_arg_fail(4)) SWIG_fail;
11977 }
11978 }
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11982
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 {
11987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11988 }
11989 {
11990 if (temp2)
11991 delete arg2;
11992 }
11993 {
11994 if (temp3)
11995 delete arg3;
11996 }
11997 return resultobj;
11998 fail:
11999 {
12000 if (temp2)
12001 delete arg2;
12002 }
12003 {
12004 if (temp3)
12005 delete arg3;
12006 }
12007 return NULL;
12008 }
12009
12010
12011 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj;
12013 wxImage *arg1 = (wxImage *) 0 ;
12014 wxString *arg2 = 0 ;
12015 int arg3 ;
12016 bool result;
12017 bool temp2 = false ;
12018 PyObject * obj0 = 0 ;
12019 PyObject * obj1 = 0 ;
12020 PyObject * obj2 = 0 ;
12021 char *kwnames[] = {
12022 (char *) "self",(char *) "name",(char *) "type", NULL
12023 };
12024
12025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12027 if (SWIG_arg_fail(1)) SWIG_fail;
12028 {
12029 arg2 = wxString_in_helper(obj1);
12030 if (arg2 == NULL) SWIG_fail;
12031 temp2 = true;
12032 }
12033 {
12034 arg3 = (int)(SWIG_As_int(obj2));
12035 if (SWIG_arg_fail(3)) SWIG_fail;
12036 }
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12040
12041 wxPyEndAllowThreads(__tstate);
12042 if (PyErr_Occurred()) SWIG_fail;
12043 }
12044 {
12045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12046 }
12047 {
12048 if (temp2)
12049 delete arg2;
12050 }
12051 return resultobj;
12052 fail:
12053 {
12054 if (temp2)
12055 delete arg2;
12056 }
12057 return NULL;
12058 }
12059
12060
12061 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12062 PyObject *resultobj;
12063 wxImage *arg1 = (wxImage *) 0 ;
12064 wxString *arg2 = 0 ;
12065 wxString *arg3 = 0 ;
12066 bool result;
12067 bool temp2 = false ;
12068 bool temp3 = false ;
12069 PyObject * obj0 = 0 ;
12070 PyObject * obj1 = 0 ;
12071 PyObject * obj2 = 0 ;
12072 char *kwnames[] = {
12073 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12074 };
12075
12076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12078 if (SWIG_arg_fail(1)) SWIG_fail;
12079 {
12080 arg2 = wxString_in_helper(obj1);
12081 if (arg2 == NULL) SWIG_fail;
12082 temp2 = true;
12083 }
12084 {
12085 arg3 = wxString_in_helper(obj2);
12086 if (arg3 == NULL) SWIG_fail;
12087 temp3 = true;
12088 }
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12092
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 {
12097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12098 }
12099 {
12100 if (temp2)
12101 delete arg2;
12102 }
12103 {
12104 if (temp3)
12105 delete arg3;
12106 }
12107 return resultobj;
12108 fail:
12109 {
12110 if (temp2)
12111 delete arg2;
12112 }
12113 {
12114 if (temp3)
12115 delete arg3;
12116 }
12117 return NULL;
12118 }
12119
12120
12121 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj;
12123 wxInputStream *arg1 = 0 ;
12124 bool result;
12125 wxPyInputStream *temp1 ;
12126 bool created1 ;
12127 PyObject * obj0 = 0 ;
12128 char *kwnames[] = {
12129 (char *) "stream", NULL
12130 };
12131
12132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12133 {
12134 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12135 arg1 = temp1->m_wxis;
12136 created1 = false;
12137 } else {
12138 PyErr_Clear(); // clear the failure of the wxPyConvert above
12139 arg1 = wxPyCBInputStream_create(obj0, false);
12140 if (arg1 == NULL) {
12141 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12142 SWIG_fail;
12143 }
12144 created1 = true;
12145 }
12146 }
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 result = (bool)wxImage::CanRead(*arg1);
12150
12151 wxPyEndAllowThreads(__tstate);
12152 if (PyErr_Occurred()) SWIG_fail;
12153 }
12154 {
12155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12156 }
12157 {
12158 if (created1) delete arg1;
12159 }
12160 return resultobj;
12161 fail:
12162 {
12163 if (created1) delete arg1;
12164 }
12165 return NULL;
12166 }
12167
12168
12169 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj;
12171 wxImage *arg1 = (wxImage *) 0 ;
12172 wxInputStream *arg2 = 0 ;
12173 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12174 int arg4 = (int) -1 ;
12175 bool result;
12176 wxPyInputStream *temp2 ;
12177 bool created2 ;
12178 PyObject * obj0 = 0 ;
12179 PyObject * obj1 = 0 ;
12180 PyObject * obj2 = 0 ;
12181 PyObject * obj3 = 0 ;
12182 char *kwnames[] = {
12183 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12184 };
12185
12186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12188 if (SWIG_arg_fail(1)) SWIG_fail;
12189 {
12190 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12191 arg2 = temp2->m_wxis;
12192 created2 = false;
12193 } else {
12194 PyErr_Clear(); // clear the failure of the wxPyConvert above
12195 arg2 = wxPyCBInputStream_create(obj1, false);
12196 if (arg2 == NULL) {
12197 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12198 SWIG_fail;
12199 }
12200 created2 = true;
12201 }
12202 }
12203 if (obj2) {
12204 {
12205 arg3 = (long)(SWIG_As_long(obj2));
12206 if (SWIG_arg_fail(3)) SWIG_fail;
12207 }
12208 }
12209 if (obj3) {
12210 {
12211 arg4 = (int)(SWIG_As_int(obj3));
12212 if (SWIG_arg_fail(4)) SWIG_fail;
12213 }
12214 }
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12224 }
12225 {
12226 if (created2) delete arg2;
12227 }
12228 return resultobj;
12229 fail:
12230 {
12231 if (created2) delete arg2;
12232 }
12233 return NULL;
12234 }
12235
12236
12237 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj;
12239 wxImage *arg1 = (wxImage *) 0 ;
12240 wxInputStream *arg2 = 0 ;
12241 wxString *arg3 = 0 ;
12242 int arg4 = (int) -1 ;
12243 bool result;
12244 wxPyInputStream *temp2 ;
12245 bool created2 ;
12246 bool temp3 = false ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 PyObject * obj2 = 0 ;
12250 PyObject * obj3 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 {
12259 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12260 arg2 = temp2->m_wxis;
12261 created2 = false;
12262 } else {
12263 PyErr_Clear(); // clear the failure of the wxPyConvert above
12264 arg2 = wxPyCBInputStream_create(obj1, false);
12265 if (arg2 == NULL) {
12266 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12267 SWIG_fail;
12268 }
12269 created2 = true;
12270 }
12271 }
12272 {
12273 arg3 = wxString_in_helper(obj2);
12274 if (arg3 == NULL) SWIG_fail;
12275 temp3 = true;
12276 }
12277 if (obj3) {
12278 {
12279 arg4 = (int)(SWIG_As_int(obj3));
12280 if (SWIG_arg_fail(4)) SWIG_fail;
12281 }
12282 }
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 {
12291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12292 }
12293 {
12294 if (created2) delete arg2;
12295 }
12296 {
12297 if (temp3)
12298 delete arg3;
12299 }
12300 return resultobj;
12301 fail:
12302 {
12303 if (created2) delete arg2;
12304 }
12305 {
12306 if (temp3)
12307 delete arg3;
12308 }
12309 return NULL;
12310 }
12311
12312
12313 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12314 PyObject *resultobj;
12315 wxImage *arg1 = (wxImage *) 0 ;
12316 bool result;
12317 PyObject * obj0 = 0 ;
12318 char *kwnames[] = {
12319 (char *) "self", NULL
12320 };
12321
12322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12324 if (SWIG_arg_fail(1)) SWIG_fail;
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (bool)(arg1)->Ok();
12328
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 {
12333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12334 }
12335 return resultobj;
12336 fail:
12337 return NULL;
12338 }
12339
12340
12341 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12342 PyObject *resultobj;
12343 wxImage *arg1 = (wxImage *) 0 ;
12344 int result;
12345 PyObject * obj0 = 0 ;
12346 char *kwnames[] = {
12347 (char *) "self", NULL
12348 };
12349
12350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12352 if (SWIG_arg_fail(1)) SWIG_fail;
12353 {
12354 PyThreadState* __tstate = wxPyBeginAllowThreads();
12355 result = (int)(arg1)->GetWidth();
12356
12357 wxPyEndAllowThreads(__tstate);
12358 if (PyErr_Occurred()) SWIG_fail;
12359 }
12360 {
12361 resultobj = SWIG_From_int((int)(result));
12362 }
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj;
12371 wxImage *arg1 = (wxImage *) 0 ;
12372 int result;
12373 PyObject * obj0 = 0 ;
12374 char *kwnames[] = {
12375 (char *) "self", NULL
12376 };
12377
12378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12380 if (SWIG_arg_fail(1)) SWIG_fail;
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (int)(arg1)->GetHeight();
12384
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 {
12389 resultobj = SWIG_From_int((int)(result));
12390 }
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj;
12399 wxImage *arg1 = (wxImage *) 0 ;
12400 wxSize result;
12401 PyObject * obj0 = 0 ;
12402 char *kwnames[] = {
12403 (char *) "self", NULL
12404 };
12405
12406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12408 if (SWIG_arg_fail(1)) SWIG_fail;
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 result = wxImage_GetSize(arg1);
12412
12413 wxPyEndAllowThreads(__tstate);
12414 if (PyErr_Occurred()) SWIG_fail;
12415 }
12416 {
12417 wxSize * resultptr;
12418 resultptr = new wxSize((wxSize &)(result));
12419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj;
12429 wxImage *arg1 = (wxImage *) 0 ;
12430 wxRect *arg2 = 0 ;
12431 SwigValueWrapper<wxImage > result;
12432 wxRect temp2 ;
12433 PyObject * obj0 = 0 ;
12434 PyObject * obj1 = 0 ;
12435 char *kwnames[] = {
12436 (char *) "self",(char *) "rect", NULL
12437 };
12438
12439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12441 if (SWIG_arg_fail(1)) SWIG_fail;
12442 {
12443 arg2 = &temp2;
12444 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 {
12454 wxImage * resultptr;
12455 resultptr = new wxImage((wxImage &)(result));
12456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj;
12466 wxImage *arg1 = (wxImage *) 0 ;
12467 wxSize *arg2 = 0 ;
12468 wxPoint *arg3 = 0 ;
12469 int arg4 = (int) -1 ;
12470 int arg5 = (int) -1 ;
12471 int arg6 = (int) -1 ;
12472 SwigValueWrapper<wxImage > result;
12473 wxSize temp2 ;
12474 wxPoint temp3 ;
12475 PyObject * obj0 = 0 ;
12476 PyObject * obj1 = 0 ;
12477 PyObject * obj2 = 0 ;
12478 PyObject * obj3 = 0 ;
12479 PyObject * obj4 = 0 ;
12480 PyObject * obj5 = 0 ;
12481 char *kwnames[] = {
12482 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12483 };
12484
12485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12487 if (SWIG_arg_fail(1)) SWIG_fail;
12488 {
12489 arg2 = &temp2;
12490 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12491 }
12492 {
12493 arg3 = &temp3;
12494 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12495 }
12496 if (obj3) {
12497 {
12498 arg4 = (int)(SWIG_As_int(obj3));
12499 if (SWIG_arg_fail(4)) SWIG_fail;
12500 }
12501 }
12502 if (obj4) {
12503 {
12504 arg5 = (int)(SWIG_As_int(obj4));
12505 if (SWIG_arg_fail(5)) SWIG_fail;
12506 }
12507 }
12508 if (obj5) {
12509 {
12510 arg6 = (int)(SWIG_As_int(obj5));
12511 if (SWIG_arg_fail(6)) SWIG_fail;
12512 }
12513 }
12514 {
12515 PyThreadState* __tstate = wxPyBeginAllowThreads();
12516 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12517
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 {
12522 wxImage * resultptr;
12523 resultptr = new wxImage((wxImage &)(result));
12524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12525 }
12526 return resultobj;
12527 fail:
12528 return NULL;
12529 }
12530
12531
12532 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12533 PyObject *resultobj;
12534 wxImage *arg1 = (wxImage *) 0 ;
12535 SwigValueWrapper<wxImage > result;
12536 PyObject * obj0 = 0 ;
12537 char *kwnames[] = {
12538 (char *) "self", NULL
12539 };
12540
12541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12543 if (SWIG_arg_fail(1)) SWIG_fail;
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (arg1)->Copy();
12547
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 wxImage * resultptr;
12553 resultptr = new wxImage((wxImage &)(result));
12554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12555 }
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj;
12564 wxImage *arg1 = (wxImage *) 0 ;
12565 wxImage *arg2 = 0 ;
12566 int arg3 ;
12567 int arg4 ;
12568 PyObject * obj0 = 0 ;
12569 PyObject * obj1 = 0 ;
12570 PyObject * obj2 = 0 ;
12571 PyObject * obj3 = 0 ;
12572 char *kwnames[] = {
12573 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12574 };
12575
12576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12578 if (SWIG_arg_fail(1)) SWIG_fail;
12579 {
12580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12581 if (SWIG_arg_fail(2)) SWIG_fail;
12582 if (arg2 == NULL) {
12583 SWIG_null_ref("wxImage");
12584 }
12585 if (SWIG_arg_fail(2)) SWIG_fail;
12586 }
12587 {
12588 arg3 = (int)(SWIG_As_int(obj2));
12589 if (SWIG_arg_fail(3)) SWIG_fail;
12590 }
12591 {
12592 arg4 = (int)(SWIG_As_int(obj3));
12593 if (SWIG_arg_fail(4)) SWIG_fail;
12594 }
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12598
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 Py_INCREF(Py_None); resultobj = Py_None;
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12610 PyObject *resultobj;
12611 wxImage *arg1 = (wxImage *) 0 ;
12612 PyObject *result;
12613 PyObject * obj0 = 0 ;
12614 char *kwnames[] = {
12615 (char *) "self", NULL
12616 };
12617
12618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12620 if (SWIG_arg_fail(1)) SWIG_fail;
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (PyObject *)wxImage_GetData(arg1);
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 resultobj = result;
12629 return resultobj;
12630 fail:
12631 return NULL;
12632 }
12633
12634
12635 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj;
12637 wxImage *arg1 = (wxImage *) 0 ;
12638 buffer arg2 ;
12639 int arg3 ;
12640 PyObject * obj0 = 0 ;
12641 PyObject * obj1 = 0 ;
12642 char *kwnames[] = {
12643 (char *) "self",(char *) "data", NULL
12644 };
12645
12646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12648 if (SWIG_arg_fail(1)) SWIG_fail;
12649 {
12650 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12651 }
12652 {
12653 PyThreadState* __tstate = wxPyBeginAllowThreads();
12654 wxImage_SetData(arg1,arg2,arg3);
12655
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 Py_INCREF(Py_None); resultobj = Py_None;
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxImage *arg1 = (wxImage *) 0 ;
12669 PyObject *result;
12670 PyObject * obj0 = 0 ;
12671 char *kwnames[] = {
12672 (char *) "self", NULL
12673 };
12674
12675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12677 if (SWIG_arg_fail(1)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12681
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 resultobj = result;
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12693 PyObject *resultobj;
12694 wxImage *arg1 = (wxImage *) 0 ;
12695 buffer arg2 ;
12696 int arg3 ;
12697 PyObject * obj0 = 0 ;
12698 PyObject * obj1 = 0 ;
12699 char *kwnames[] = {
12700 (char *) "self",(char *) "data", NULL
12701 };
12702
12703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12705 if (SWIG_arg_fail(1)) SWIG_fail;
12706 {
12707 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12708 }
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 wxImage_SetDataBuffer(arg1,arg2,arg3);
12712
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 Py_INCREF(Py_None); resultobj = Py_None;
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12724 PyObject *resultobj;
12725 wxImage *arg1 = (wxImage *) 0 ;
12726 PyObject *result;
12727 PyObject * obj0 = 0 ;
12728 char *kwnames[] = {
12729 (char *) "self", NULL
12730 };
12731
12732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12734 if (SWIG_arg_fail(1)) SWIG_fail;
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (PyObject *)wxImage_GetAlphaData(arg1);
12738
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 resultobj = result;
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12750 PyObject *resultobj;
12751 wxImage *arg1 = (wxImage *) 0 ;
12752 buffer arg2 ;
12753 int arg3 ;
12754 PyObject * obj0 = 0 ;
12755 PyObject * obj1 = 0 ;
12756 char *kwnames[] = {
12757 (char *) "self",(char *) "alpha", NULL
12758 };
12759
12760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12762 if (SWIG_arg_fail(1)) SWIG_fail;
12763 {
12764 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12765 }
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 wxImage_SetAlphaData(arg1,arg2,arg3);
12769
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 Py_INCREF(Py_None); resultobj = Py_None;
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12781 PyObject *resultobj;
12782 wxImage *arg1 = (wxImage *) 0 ;
12783 PyObject *result;
12784 PyObject * obj0 = 0 ;
12785 char *kwnames[] = {
12786 (char *) "self", NULL
12787 };
12788
12789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12791 if (SWIG_arg_fail(1)) SWIG_fail;
12792 {
12793 PyThreadState* __tstate = wxPyBeginAllowThreads();
12794 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12795
12796 wxPyEndAllowThreads(__tstate);
12797 if (PyErr_Occurred()) SWIG_fail;
12798 }
12799 resultobj = result;
12800 return resultobj;
12801 fail:
12802 return NULL;
12803 }
12804
12805
12806 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12807 PyObject *resultobj;
12808 wxImage *arg1 = (wxImage *) 0 ;
12809 buffer arg2 ;
12810 int arg3 ;
12811 PyObject * obj0 = 0 ;
12812 PyObject * obj1 = 0 ;
12813 char *kwnames[] = {
12814 (char *) "self",(char *) "alpha", NULL
12815 };
12816
12817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12819 if (SWIG_arg_fail(1)) SWIG_fail;
12820 {
12821 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12822 }
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12826
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 Py_INCREF(Py_None); resultobj = Py_None;
12831 return resultobj;
12832 fail:
12833 return NULL;
12834 }
12835
12836
12837 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12838 PyObject *resultobj;
12839 wxImage *arg1 = (wxImage *) 0 ;
12840 byte arg2 ;
12841 byte arg3 ;
12842 byte arg4 ;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 PyObject * obj2 = 0 ;
12846 PyObject * obj3 = 0 ;
12847 char *kwnames[] = {
12848 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12849 };
12850
12851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12853 if (SWIG_arg_fail(1)) SWIG_fail;
12854 {
12855 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12856 if (SWIG_arg_fail(2)) SWIG_fail;
12857 }
12858 {
12859 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12860 if (SWIG_arg_fail(3)) SWIG_fail;
12861 }
12862 {
12863 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12864 if (SWIG_arg_fail(4)) SWIG_fail;
12865 }
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 (arg1)->SetMaskColour(arg2,arg3,arg4);
12869
12870 wxPyEndAllowThreads(__tstate);
12871 if (PyErr_Occurred()) SWIG_fail;
12872 }
12873 Py_INCREF(Py_None); resultobj = Py_None;
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12881 PyObject *resultobj;
12882 wxImage *arg1 = (wxImage *) 0 ;
12883 byte *arg2 = (byte *) 0 ;
12884 byte *arg3 = (byte *) 0 ;
12885 byte *arg4 = (byte *) 0 ;
12886 byte temp2 ;
12887 int res2 = 0 ;
12888 byte temp3 ;
12889 int res3 = 0 ;
12890 byte temp4 ;
12891 int res4 = 0 ;
12892 PyObject * obj0 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self", NULL
12895 };
12896
12897 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12898 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12899 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12902 if (SWIG_arg_fail(1)) SWIG_fail;
12903 {
12904 PyThreadState* __tstate = wxPyBeginAllowThreads();
12905 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12906
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 Py_INCREF(Py_None); resultobj = Py_None;
12911 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12912 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12913 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12914 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12915 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12916 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj;
12925 wxImage *arg1 = (wxImage *) 0 ;
12926 byte result;
12927 PyObject * obj0 = 0 ;
12928 char *kwnames[] = {
12929 (char *) "self", NULL
12930 };
12931
12932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12934 if (SWIG_arg_fail(1)) SWIG_fail;
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = (byte)(arg1)->GetMaskRed();
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 {
12943 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12944 }
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12952 PyObject *resultobj;
12953 wxImage *arg1 = (wxImage *) 0 ;
12954 byte result;
12955 PyObject * obj0 = 0 ;
12956 char *kwnames[] = {
12957 (char *) "self", NULL
12958 };
12959
12960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12962 if (SWIG_arg_fail(1)) SWIG_fail;
12963 {
12964 PyThreadState* __tstate = wxPyBeginAllowThreads();
12965 result = (byte)(arg1)->GetMaskGreen();
12966
12967 wxPyEndAllowThreads(__tstate);
12968 if (PyErr_Occurred()) SWIG_fail;
12969 }
12970 {
12971 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12972 }
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj;
12981 wxImage *arg1 = (wxImage *) 0 ;
12982 byte result;
12983 PyObject * obj0 = 0 ;
12984 char *kwnames[] = {
12985 (char *) "self", NULL
12986 };
12987
12988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12990 if (SWIG_arg_fail(1)) SWIG_fail;
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 result = (byte)(arg1)->GetMaskBlue();
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 {
12999 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13000 }
13001 return resultobj;
13002 fail:
13003 return NULL;
13004 }
13005
13006
13007 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13008 PyObject *resultobj;
13009 wxImage *arg1 = (wxImage *) 0 ;
13010 bool arg2 = (bool) true ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self",(char *) "mask", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13019 if (SWIG_arg_fail(1)) SWIG_fail;
13020 if (obj1) {
13021 {
13022 arg2 = (bool)(SWIG_As_bool(obj1));
13023 if (SWIG_arg_fail(2)) SWIG_fail;
13024 }
13025 }
13026 {
13027 PyThreadState* __tstate = wxPyBeginAllowThreads();
13028 (arg1)->SetMask(arg2);
13029
13030 wxPyEndAllowThreads(__tstate);
13031 if (PyErr_Occurred()) SWIG_fail;
13032 }
13033 Py_INCREF(Py_None); resultobj = Py_None;
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj;
13042 wxImage *arg1 = (wxImage *) 0 ;
13043 bool result;
13044 PyObject * obj0 = 0 ;
13045 char *kwnames[] = {
13046 (char *) "self", NULL
13047 };
13048
13049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13051 if (SWIG_arg_fail(1)) SWIG_fail;
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 result = (bool)(arg1)->HasMask();
13055
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 {
13060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13061 }
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13069 PyObject *resultobj;
13070 wxImage *arg1 = (wxImage *) 0 ;
13071 double arg2 ;
13072 wxPoint *arg3 = 0 ;
13073 bool arg4 = (bool) true ;
13074 wxPoint *arg5 = (wxPoint *) NULL ;
13075 SwigValueWrapper<wxImage > result;
13076 wxPoint temp3 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 PyObject * obj2 = 0 ;
13080 PyObject * obj3 = 0 ;
13081 PyObject * obj4 = 0 ;
13082 char *kwnames[] = {
13083 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13084 };
13085
13086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13088 if (SWIG_arg_fail(1)) SWIG_fail;
13089 {
13090 arg2 = (double)(SWIG_As_double(obj1));
13091 if (SWIG_arg_fail(2)) SWIG_fail;
13092 }
13093 {
13094 arg3 = &temp3;
13095 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13096 }
13097 if (obj3) {
13098 {
13099 arg4 = (bool)(SWIG_As_bool(obj3));
13100 if (SWIG_arg_fail(4)) SWIG_fail;
13101 }
13102 }
13103 if (obj4) {
13104 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13105 if (SWIG_arg_fail(5)) SWIG_fail;
13106 }
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 wxImage * resultptr;
13116 resultptr = new wxImage((wxImage &)(result));
13117 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13118 }
13119 return resultobj;
13120 fail:
13121 return NULL;
13122 }
13123
13124
13125 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13126 PyObject *resultobj;
13127 wxImage *arg1 = (wxImage *) 0 ;
13128 bool arg2 = (bool) true ;
13129 SwigValueWrapper<wxImage > result;
13130 PyObject * obj0 = 0 ;
13131 PyObject * obj1 = 0 ;
13132 char *kwnames[] = {
13133 (char *) "self",(char *) "clockwise", NULL
13134 };
13135
13136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13138 if (SWIG_arg_fail(1)) SWIG_fail;
13139 if (obj1) {
13140 {
13141 arg2 = (bool)(SWIG_As_bool(obj1));
13142 if (SWIG_arg_fail(2)) SWIG_fail;
13143 }
13144 }
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 result = (arg1)->Rotate90(arg2);
13148
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 {
13153 wxImage * resultptr;
13154 resultptr = new wxImage((wxImage &)(result));
13155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13156 }
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13164 PyObject *resultobj;
13165 wxImage *arg1 = (wxImage *) 0 ;
13166 bool arg2 = (bool) true ;
13167 SwigValueWrapper<wxImage > result;
13168 PyObject * obj0 = 0 ;
13169 PyObject * obj1 = 0 ;
13170 char *kwnames[] = {
13171 (char *) "self",(char *) "horizontally", NULL
13172 };
13173
13174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13176 if (SWIG_arg_fail(1)) SWIG_fail;
13177 if (obj1) {
13178 {
13179 arg2 = (bool)(SWIG_As_bool(obj1));
13180 if (SWIG_arg_fail(2)) SWIG_fail;
13181 }
13182 }
13183 {
13184 PyThreadState* __tstate = wxPyBeginAllowThreads();
13185 result = (arg1)->Mirror(arg2);
13186
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 {
13191 wxImage * resultptr;
13192 resultptr = new wxImage((wxImage &)(result));
13193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13194 }
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13202 PyObject *resultobj;
13203 wxImage *arg1 = (wxImage *) 0 ;
13204 byte arg2 ;
13205 byte arg3 ;
13206 byte arg4 ;
13207 byte arg5 ;
13208 byte arg6 ;
13209 byte arg7 ;
13210 PyObject * obj0 = 0 ;
13211 PyObject * obj1 = 0 ;
13212 PyObject * obj2 = 0 ;
13213 PyObject * obj3 = 0 ;
13214 PyObject * obj4 = 0 ;
13215 PyObject * obj5 = 0 ;
13216 PyObject * obj6 = 0 ;
13217 char *kwnames[] = {
13218 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13219 };
13220
13221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13223 if (SWIG_arg_fail(1)) SWIG_fail;
13224 {
13225 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13226 if (SWIG_arg_fail(2)) SWIG_fail;
13227 }
13228 {
13229 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13230 if (SWIG_arg_fail(3)) SWIG_fail;
13231 }
13232 {
13233 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13234 if (SWIG_arg_fail(4)) SWIG_fail;
13235 }
13236 {
13237 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13238 if (SWIG_arg_fail(5)) SWIG_fail;
13239 }
13240 {
13241 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13242 if (SWIG_arg_fail(6)) SWIG_fail;
13243 }
13244 {
13245 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13246 if (SWIG_arg_fail(7)) SWIG_fail;
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13251
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 Py_INCREF(Py_None); resultobj = Py_None;
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj;
13264 wxImage *arg1 = (wxImage *) 0 ;
13265 byte arg2 ;
13266 byte arg3 ;
13267 byte arg4 ;
13268 SwigValueWrapper<wxImage > result;
13269 PyObject * obj0 = 0 ;
13270 PyObject * obj1 = 0 ;
13271 PyObject * obj2 = 0 ;
13272 PyObject * obj3 = 0 ;
13273 char *kwnames[] = {
13274 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13275 };
13276
13277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13279 if (SWIG_arg_fail(1)) SWIG_fail;
13280 {
13281 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13282 if (SWIG_arg_fail(2)) SWIG_fail;
13283 }
13284 {
13285 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13286 if (SWIG_arg_fail(3)) SWIG_fail;
13287 }
13288 {
13289 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13290 if (SWIG_arg_fail(4)) SWIG_fail;
13291 }
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13295
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 {
13300 wxImage * resultptr;
13301 resultptr = new wxImage((wxImage &)(result));
13302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13303 }
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj;
13312 wxImage *arg1 = (wxImage *) 0 ;
13313 wxString *arg2 = 0 ;
13314 wxString *arg3 = 0 ;
13315 bool temp2 = false ;
13316 bool temp3 = false ;
13317 PyObject * obj0 = 0 ;
13318 PyObject * obj1 = 0 ;
13319 PyObject * obj2 = 0 ;
13320 char *kwnames[] = {
13321 (char *) "self",(char *) "name",(char *) "value", NULL
13322 };
13323
13324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13326 if (SWIG_arg_fail(1)) SWIG_fail;
13327 {
13328 arg2 = wxString_in_helper(obj1);
13329 if (arg2 == NULL) SWIG_fail;
13330 temp2 = true;
13331 }
13332 {
13333 arg3 = wxString_in_helper(obj2);
13334 if (arg3 == NULL) SWIG_fail;
13335 temp3 = true;
13336 }
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13340
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 Py_INCREF(Py_None); resultobj = Py_None;
13345 {
13346 if (temp2)
13347 delete arg2;
13348 }
13349 {
13350 if (temp3)
13351 delete arg3;
13352 }
13353 return resultobj;
13354 fail:
13355 {
13356 if (temp2)
13357 delete arg2;
13358 }
13359 {
13360 if (temp3)
13361 delete arg3;
13362 }
13363 return NULL;
13364 }
13365
13366
13367 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13368 PyObject *resultobj;
13369 wxImage *arg1 = (wxImage *) 0 ;
13370 wxString *arg2 = 0 ;
13371 int arg3 ;
13372 bool temp2 = false ;
13373 PyObject * obj0 = 0 ;
13374 PyObject * obj1 = 0 ;
13375 PyObject * obj2 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self",(char *) "name",(char *) "value", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 {
13384 arg2 = wxString_in_helper(obj1);
13385 if (arg2 == NULL) SWIG_fail;
13386 temp2 = true;
13387 }
13388 {
13389 arg3 = (int)(SWIG_As_int(obj2));
13390 if (SWIG_arg_fail(3)) SWIG_fail;
13391 }
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 (arg1)->SetOption((wxString const &)*arg2,arg3);
13395
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 Py_INCREF(Py_None); resultobj = Py_None;
13400 {
13401 if (temp2)
13402 delete arg2;
13403 }
13404 return resultobj;
13405 fail:
13406 {
13407 if (temp2)
13408 delete arg2;
13409 }
13410 return NULL;
13411 }
13412
13413
13414 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj;
13416 wxImage *arg1 = (wxImage *) 0 ;
13417 wxString *arg2 = 0 ;
13418 wxString result;
13419 bool temp2 = false ;
13420 PyObject * obj0 = 0 ;
13421 PyObject * obj1 = 0 ;
13422 char *kwnames[] = {
13423 (char *) "self",(char *) "name", NULL
13424 };
13425
13426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13428 if (SWIG_arg_fail(1)) SWIG_fail;
13429 {
13430 arg2 = wxString_in_helper(obj1);
13431 if (arg2 == NULL) SWIG_fail;
13432 temp2 = true;
13433 }
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13437
13438 wxPyEndAllowThreads(__tstate);
13439 if (PyErr_Occurred()) SWIG_fail;
13440 }
13441 {
13442 #if wxUSE_UNICODE
13443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13444 #else
13445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13446 #endif
13447 }
13448 {
13449 if (temp2)
13450 delete arg2;
13451 }
13452 return resultobj;
13453 fail:
13454 {
13455 if (temp2)
13456 delete arg2;
13457 }
13458 return NULL;
13459 }
13460
13461
13462 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj;
13464 wxImage *arg1 = (wxImage *) 0 ;
13465 wxString *arg2 = 0 ;
13466 int result;
13467 bool temp2 = false ;
13468 PyObject * obj0 = 0 ;
13469 PyObject * obj1 = 0 ;
13470 char *kwnames[] = {
13471 (char *) "self",(char *) "name", NULL
13472 };
13473
13474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13476 if (SWIG_arg_fail(1)) SWIG_fail;
13477 {
13478 arg2 = wxString_in_helper(obj1);
13479 if (arg2 == NULL) SWIG_fail;
13480 temp2 = true;
13481 }
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13485
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = SWIG_From_int((int)(result));
13491 }
13492 {
13493 if (temp2)
13494 delete arg2;
13495 }
13496 return resultobj;
13497 fail:
13498 {
13499 if (temp2)
13500 delete arg2;
13501 }
13502 return NULL;
13503 }
13504
13505
13506 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj;
13508 wxImage *arg1 = (wxImage *) 0 ;
13509 wxString *arg2 = 0 ;
13510 bool result;
13511 bool temp2 = false ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 char *kwnames[] = {
13515 (char *) "self",(char *) "name", NULL
13516 };
13517
13518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13520 if (SWIG_arg_fail(1)) SWIG_fail;
13521 {
13522 arg2 = wxString_in_helper(obj1);
13523 if (arg2 == NULL) SWIG_fail;
13524 temp2 = true;
13525 }
13526 {
13527 PyThreadState* __tstate = wxPyBeginAllowThreads();
13528 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13529
13530 wxPyEndAllowThreads(__tstate);
13531 if (PyErr_Occurred()) SWIG_fail;
13532 }
13533 {
13534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13535 }
13536 {
13537 if (temp2)
13538 delete arg2;
13539 }
13540 return resultobj;
13541 fail:
13542 {
13543 if (temp2)
13544 delete arg2;
13545 }
13546 return NULL;
13547 }
13548
13549
13550 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13551 PyObject *resultobj;
13552 wxImage *arg1 = (wxImage *) 0 ;
13553 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13554 unsigned long result;
13555 PyObject * obj0 = 0 ;
13556 PyObject * obj1 = 0 ;
13557 char *kwnames[] = {
13558 (char *) "self",(char *) "stopafter", NULL
13559 };
13560
13561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13563 if (SWIG_arg_fail(1)) SWIG_fail;
13564 if (obj1) {
13565 {
13566 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13567 if (SWIG_arg_fail(2)) SWIG_fail;
13568 }
13569 }
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 result = (unsigned long)(arg1)->CountColours(arg2);
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 {
13578 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13579 }
13580 return resultobj;
13581 fail:
13582 return NULL;
13583 }
13584
13585
13586 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13587 PyObject *resultobj;
13588 wxImage *arg1 = (wxImage *) 0 ;
13589 wxImageHistogram *arg2 = 0 ;
13590 unsigned long result;
13591 PyObject * obj0 = 0 ;
13592 PyObject * obj1 = 0 ;
13593 char *kwnames[] = {
13594 (char *) "self",(char *) "h", NULL
13595 };
13596
13597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13599 if (SWIG_arg_fail(1)) SWIG_fail;
13600 {
13601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13602 if (SWIG_arg_fail(2)) SWIG_fail;
13603 if (arg2 == NULL) {
13604 SWIG_null_ref("wxImageHistogram");
13605 }
13606 if (SWIG_arg_fail(2)) SWIG_fail;
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 {
13616 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13617 }
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj;
13626 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13627 PyObject * obj0 = 0 ;
13628 char *kwnames[] = {
13629 (char *) "handler", NULL
13630 };
13631
13632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13634 if (SWIG_arg_fail(1)) SWIG_fail;
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 wxImage::AddHandler(arg1);
13638
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 Py_INCREF(Py_None); resultobj = Py_None;
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj;
13651 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13652 PyObject * obj0 = 0 ;
13653 char *kwnames[] = {
13654 (char *) "handler", NULL
13655 };
13656
13657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13659 if (SWIG_arg_fail(1)) SWIG_fail;
13660 {
13661 PyThreadState* __tstate = wxPyBeginAllowThreads();
13662 wxImage::InsertHandler(arg1);
13663
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 Py_INCREF(Py_None); resultobj = Py_None;
13668 return resultobj;
13669 fail:
13670 return NULL;
13671 }
13672
13673
13674 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13675 PyObject *resultobj;
13676 wxString *arg1 = 0 ;
13677 bool result;
13678 bool temp1 = false ;
13679 PyObject * obj0 = 0 ;
13680 char *kwnames[] = {
13681 (char *) "name", NULL
13682 };
13683
13684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13685 {
13686 arg1 = wxString_in_helper(obj0);
13687 if (arg1 == NULL) SWIG_fail;
13688 temp1 = true;
13689 }
13690 {
13691 PyThreadState* __tstate = wxPyBeginAllowThreads();
13692 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13693
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 {
13698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13699 }
13700 {
13701 if (temp1)
13702 delete arg1;
13703 }
13704 return resultobj;
13705 fail:
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 return NULL;
13711 }
13712
13713
13714 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj;
13716 wxString result;
13717 char *kwnames[] = {
13718 NULL
13719 };
13720
13721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 result = wxImage::GetImageExtWildcard();
13725
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 {
13730 #if wxUSE_UNICODE
13731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13732 #else
13733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13734 #endif
13735 }
13736 return resultobj;
13737 fail:
13738 return NULL;
13739 }
13740
13741
13742 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj;
13744 wxImage *arg1 = (wxImage *) 0 ;
13745 int arg2 = (int) -1 ;
13746 wxBitmap result;
13747 PyObject * obj0 = 0 ;
13748 PyObject * obj1 = 0 ;
13749 char *kwnames[] = {
13750 (char *) "self",(char *) "depth", NULL
13751 };
13752
13753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13755 if (SWIG_arg_fail(1)) SWIG_fail;
13756 if (obj1) {
13757 {
13758 arg2 = (int)(SWIG_As_int(obj1));
13759 if (SWIG_arg_fail(2)) SWIG_fail;
13760 }
13761 }
13762 {
13763 if (!wxPyCheckForApp()) SWIG_fail;
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 result = wxImage_ConvertToBitmap(arg1,arg2);
13766
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 {
13771 wxBitmap * resultptr;
13772 resultptr = new wxBitmap((wxBitmap &)(result));
13773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13774 }
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj;
13783 wxImage *arg1 = (wxImage *) 0 ;
13784 byte arg2 ;
13785 byte arg3 ;
13786 byte arg4 ;
13787 wxBitmap result;
13788 PyObject * obj0 = 0 ;
13789 PyObject * obj1 = 0 ;
13790 PyObject * obj2 = 0 ;
13791 PyObject * obj3 = 0 ;
13792 char *kwnames[] = {
13793 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13794 };
13795
13796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13798 if (SWIG_arg_fail(1)) SWIG_fail;
13799 {
13800 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13801 if (SWIG_arg_fail(2)) SWIG_fail;
13802 }
13803 {
13804 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13805 if (SWIG_arg_fail(3)) SWIG_fail;
13806 }
13807 {
13808 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13809 if (SWIG_arg_fail(4)) SWIG_fail;
13810 }
13811 {
13812 if (!wxPyCheckForApp()) SWIG_fail;
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13815
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 {
13820 wxBitmap * resultptr;
13821 resultptr = new wxBitmap((wxBitmap &)(result));
13822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13823 }
13824 return resultobj;
13825 fail:
13826 return NULL;
13827 }
13828
13829
13830 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13831 PyObject *obj;
13832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13833 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13834 Py_INCREF(obj);
13835 return Py_BuildValue((char *)"");
13836 }
13837 static int _wrap_NullImage_set(PyObject *) {
13838 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13839 return 1;
13840 }
13841
13842
13843 static PyObject *_wrap_NullImage_get(void) {
13844 PyObject *pyobj;
13845
13846 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13847 return pyobj;
13848 }
13849
13850
13851 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13852 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13853 return 1;
13854 }
13855
13856
13857 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13858 PyObject *pyobj;
13859
13860 {
13861 #if wxUSE_UNICODE
13862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13863 #else
13864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13865 #endif
13866 }
13867 return pyobj;
13868 }
13869
13870
13871 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13872 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13873 return 1;
13874 }
13875
13876
13877 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13878 PyObject *pyobj;
13879
13880 {
13881 #if wxUSE_UNICODE
13882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13883 #else
13884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13885 #endif
13886 }
13887 return pyobj;
13888 }
13889
13890
13891 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13892 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13893 return 1;
13894 }
13895
13896
13897 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13898 PyObject *pyobj;
13899
13900 {
13901 #if wxUSE_UNICODE
13902 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13903 #else
13904 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13905 #endif
13906 }
13907 return pyobj;
13908 }
13909
13910
13911 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13912 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13913 return 1;
13914 }
13915
13916
13917 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13918 PyObject *pyobj;
13919
13920 {
13921 #if wxUSE_UNICODE
13922 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13923 #else
13924 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13925 #endif
13926 }
13927 return pyobj;
13928 }
13929
13930
13931 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13932 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13933 return 1;
13934 }
13935
13936
13937 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13938 PyObject *pyobj;
13939
13940 {
13941 #if wxUSE_UNICODE
13942 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13943 #else
13944 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13945 #endif
13946 }
13947 return pyobj;
13948 }
13949
13950
13951 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13952 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13953 return 1;
13954 }
13955
13956
13957 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13958 PyObject *pyobj;
13959
13960 {
13961 #if wxUSE_UNICODE
13962 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13963 #else
13964 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13965 #endif
13966 }
13967 return pyobj;
13968 }
13969
13970
13971 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13972 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13973 return 1;
13974 }
13975
13976
13977 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13978 PyObject *pyobj;
13979
13980 {
13981 #if wxUSE_UNICODE
13982 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13983 #else
13984 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13985 #endif
13986 }
13987 return pyobj;
13988 }
13989
13990
13991 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13992 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13993 return 1;
13994 }
13995
13996
13997 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13998 PyObject *pyobj;
13999
14000 {
14001 #if wxUSE_UNICODE
14002 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14003 #else
14004 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14005 #endif
14006 }
14007 return pyobj;
14008 }
14009
14010
14011 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14012 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14013 return 1;
14014 }
14015
14016
14017 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14018 PyObject *pyobj;
14019
14020 {
14021 #if wxUSE_UNICODE
14022 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14023 #else
14024 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14025 #endif
14026 }
14027 return pyobj;
14028 }
14029
14030
14031 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14032 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14033 return 1;
14034 }
14035
14036
14037 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14038 PyObject *pyobj;
14039
14040 {
14041 #if wxUSE_UNICODE
14042 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14043 #else
14044 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14045 #endif
14046 }
14047 return pyobj;
14048 }
14049
14050
14051 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14052 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14053 return 1;
14054 }
14055
14056
14057 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14058 PyObject *pyobj;
14059
14060 {
14061 #if wxUSE_UNICODE
14062 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14063 #else
14064 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14065 #endif
14066 }
14067 return pyobj;
14068 }
14069
14070
14071 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14072 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14073 return 1;
14074 }
14075
14076
14077 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14078 PyObject *pyobj;
14079
14080 {
14081 #if wxUSE_UNICODE
14082 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14083 #else
14084 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14085 #endif
14086 }
14087 return pyobj;
14088 }
14089
14090
14091 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14092 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14093 return 1;
14094 }
14095
14096
14097 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14098 PyObject *pyobj;
14099
14100 {
14101 #if wxUSE_UNICODE
14102 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14103 #else
14104 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14105 #endif
14106 }
14107 return pyobj;
14108 }
14109
14110
14111 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14112 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14113 return 1;
14114 }
14115
14116
14117 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14118 PyObject *pyobj;
14119
14120 {
14121 #if wxUSE_UNICODE
14122 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14123 #else
14124 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14125 #endif
14126 }
14127 return pyobj;
14128 }
14129
14130
14131 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14132 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14133 return 1;
14134 }
14135
14136
14137 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14138 PyObject *pyobj;
14139
14140 {
14141 #if wxUSE_UNICODE
14142 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14143 #else
14144 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14145 #endif
14146 }
14147 return pyobj;
14148 }
14149
14150
14151 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14152 PyObject *resultobj;
14153 wxBMPHandler *result;
14154 char *kwnames[] = {
14155 NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (wxBMPHandler *)new wxBMPHandler();
14162
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14174 PyObject *obj;
14175 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14176 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14177 Py_INCREF(obj);
14178 return Py_BuildValue((char *)"");
14179 }
14180 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14181 PyObject *resultobj;
14182 wxICOHandler *result;
14183 char *kwnames[] = {
14184 NULL
14185 };
14186
14187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 result = (wxICOHandler *)new wxICOHandler();
14191
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14203 PyObject *obj;
14204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14205 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14206 Py_INCREF(obj);
14207 return Py_BuildValue((char *)"");
14208 }
14209 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14210 PyObject *resultobj;
14211 wxCURHandler *result;
14212 char *kwnames[] = {
14213 NULL
14214 };
14215
14216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14217 {
14218 PyThreadState* __tstate = wxPyBeginAllowThreads();
14219 result = (wxCURHandler *)new wxCURHandler();
14220
14221 wxPyEndAllowThreads(__tstate);
14222 if (PyErr_Occurred()) SWIG_fail;
14223 }
14224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14232 PyObject *obj;
14233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14234 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14235 Py_INCREF(obj);
14236 return Py_BuildValue((char *)"");
14237 }
14238 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14239 PyObject *resultobj;
14240 wxANIHandler *result;
14241 char *kwnames[] = {
14242 NULL
14243 };
14244
14245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14246 {
14247 PyThreadState* __tstate = wxPyBeginAllowThreads();
14248 result = (wxANIHandler *)new wxANIHandler();
14249
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14254 return resultobj;
14255 fail:
14256 return NULL;
14257 }
14258
14259
14260 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14261 PyObject *obj;
14262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14263 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14264 Py_INCREF(obj);
14265 return Py_BuildValue((char *)"");
14266 }
14267 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14268 PyObject *resultobj;
14269 wxPNGHandler *result;
14270 char *kwnames[] = {
14271 NULL
14272 };
14273
14274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14275 {
14276 PyThreadState* __tstate = wxPyBeginAllowThreads();
14277 result = (wxPNGHandler *)new wxPNGHandler();
14278
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14283 return resultobj;
14284 fail:
14285 return NULL;
14286 }
14287
14288
14289 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14290 PyObject *obj;
14291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14292 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14293 Py_INCREF(obj);
14294 return Py_BuildValue((char *)"");
14295 }
14296 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14297 PyObject *resultobj;
14298 wxGIFHandler *result;
14299 char *kwnames[] = {
14300 NULL
14301 };
14302
14303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 result = (wxGIFHandler *)new wxGIFHandler();
14307
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14319 PyObject *obj;
14320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14321 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14322 Py_INCREF(obj);
14323 return Py_BuildValue((char *)"");
14324 }
14325 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14326 PyObject *resultobj;
14327 wxPCXHandler *result;
14328 char *kwnames[] = {
14329 NULL
14330 };
14331
14332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14333 {
14334 PyThreadState* __tstate = wxPyBeginAllowThreads();
14335 result = (wxPCXHandler *)new wxPCXHandler();
14336
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14348 PyObject *obj;
14349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14350 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14351 Py_INCREF(obj);
14352 return Py_BuildValue((char *)"");
14353 }
14354 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14355 PyObject *resultobj;
14356 wxJPEGHandler *result;
14357 char *kwnames[] = {
14358 NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (wxJPEGHandler *)new wxJPEGHandler();
14365
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14377 PyObject *obj;
14378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14379 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14380 Py_INCREF(obj);
14381 return Py_BuildValue((char *)"");
14382 }
14383 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj;
14385 wxPNMHandler *result;
14386 char *kwnames[] = {
14387 NULL
14388 };
14389
14390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 result = (wxPNMHandler *)new wxPNMHandler();
14394
14395 wxPyEndAllowThreads(__tstate);
14396 if (PyErr_Occurred()) SWIG_fail;
14397 }
14398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14399 return resultobj;
14400 fail:
14401 return NULL;
14402 }
14403
14404
14405 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14406 PyObject *obj;
14407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14408 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14409 Py_INCREF(obj);
14410 return Py_BuildValue((char *)"");
14411 }
14412 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14413 PyObject *resultobj;
14414 wxXPMHandler *result;
14415 char *kwnames[] = {
14416 NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14420 {
14421 PyThreadState* __tstate = wxPyBeginAllowThreads();
14422 result = (wxXPMHandler *)new wxXPMHandler();
14423
14424 wxPyEndAllowThreads(__tstate);
14425 if (PyErr_Occurred()) SWIG_fail;
14426 }
14427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14428 return resultobj;
14429 fail:
14430 return NULL;
14431 }
14432
14433
14434 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14435 PyObject *obj;
14436 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14437 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14438 Py_INCREF(obj);
14439 return Py_BuildValue((char *)"");
14440 }
14441 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj;
14443 wxTIFFHandler *result;
14444 char *kwnames[] = {
14445 NULL
14446 };
14447
14448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = (wxTIFFHandler *)new wxTIFFHandler();
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14464 PyObject *obj;
14465 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14466 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14467 Py_INCREF(obj);
14468 return Py_BuildValue((char *)"");
14469 }
14470 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14471 PyObject *resultobj;
14472 wxImage *arg1 = 0 ;
14473 wxImage *arg2 = 0 ;
14474 int arg3 = (int) 236 ;
14475 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14476 bool result;
14477 PyObject * obj0 = 0 ;
14478 PyObject * obj1 = 0 ;
14479 PyObject * obj2 = 0 ;
14480 PyObject * obj3 = 0 ;
14481 char *kwnames[] = {
14482 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14483 };
14484
14485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14486 {
14487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14488 if (SWIG_arg_fail(1)) SWIG_fail;
14489 if (arg1 == NULL) {
14490 SWIG_null_ref("wxImage");
14491 }
14492 if (SWIG_arg_fail(1)) SWIG_fail;
14493 }
14494 {
14495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14496 if (SWIG_arg_fail(2)) SWIG_fail;
14497 if (arg2 == NULL) {
14498 SWIG_null_ref("wxImage");
14499 }
14500 if (SWIG_arg_fail(2)) SWIG_fail;
14501 }
14502 if (obj2) {
14503 {
14504 arg3 = (int)(SWIG_As_int(obj2));
14505 if (SWIG_arg_fail(3)) SWIG_fail;
14506 }
14507 }
14508 if (obj3) {
14509 {
14510 arg4 = (int)(SWIG_As_int(obj3));
14511 if (SWIG_arg_fail(4)) SWIG_fail;
14512 }
14513 }
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 {
14522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14523 }
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14531 PyObject *obj;
14532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14533 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14534 Py_INCREF(obj);
14535 return Py_BuildValue((char *)"");
14536 }
14537 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj;
14539 wxEvtHandler *result;
14540 char *kwnames[] = {
14541 NULL
14542 };
14543
14544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (wxEvtHandler *)new wxEvtHandler();
14548
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14553 return resultobj;
14554 fail:
14555 return NULL;
14556 }
14557
14558
14559 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj;
14561 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14562 wxEvtHandler *result;
14563 PyObject * obj0 = 0 ;
14564 char *kwnames[] = {
14565 (char *) "self", NULL
14566 };
14567
14568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14570 if (SWIG_arg_fail(1)) SWIG_fail;
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14574
14575 wxPyEndAllowThreads(__tstate);
14576 if (PyErr_Occurred()) SWIG_fail;
14577 }
14578 {
14579 resultobj = wxPyMake_wxObject(result, 0);
14580 }
14581 return resultobj;
14582 fail:
14583 return NULL;
14584 }
14585
14586
14587 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14588 PyObject *resultobj;
14589 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14590 wxEvtHandler *result;
14591 PyObject * obj0 = 0 ;
14592 char *kwnames[] = {
14593 (char *) "self", NULL
14594 };
14595
14596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14598 if (SWIG_arg_fail(1)) SWIG_fail;
14599 {
14600 PyThreadState* __tstate = wxPyBeginAllowThreads();
14601 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14602
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 {
14607 resultobj = wxPyMake_wxObject(result, 0);
14608 }
14609 return resultobj;
14610 fail:
14611 return NULL;
14612 }
14613
14614
14615 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14616 PyObject *resultobj;
14617 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14618 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14619 PyObject * obj0 = 0 ;
14620 PyObject * obj1 = 0 ;
14621 char *kwnames[] = {
14622 (char *) "self",(char *) "handler", NULL
14623 };
14624
14625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14627 if (SWIG_arg_fail(1)) SWIG_fail;
14628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14629 if (SWIG_arg_fail(2)) SWIG_fail;
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 (arg1)->SetNextHandler(arg2);
14633
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 Py_INCREF(Py_None); resultobj = Py_None;
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj;
14646 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14647 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14648 PyObject * obj0 = 0 ;
14649 PyObject * obj1 = 0 ;
14650 char *kwnames[] = {
14651 (char *) "self",(char *) "handler", NULL
14652 };
14653
14654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14656 if (SWIG_arg_fail(1)) SWIG_fail;
14657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14658 if (SWIG_arg_fail(2)) SWIG_fail;
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 (arg1)->SetPreviousHandler(arg2);
14662
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 Py_INCREF(Py_None); resultobj = Py_None;
14667 return resultobj;
14668 fail:
14669 return NULL;
14670 }
14671
14672
14673 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14674 PyObject *resultobj;
14675 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14676 bool result;
14677 PyObject * obj0 = 0 ;
14678 char *kwnames[] = {
14679 (char *) "self", NULL
14680 };
14681
14682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14684 if (SWIG_arg_fail(1)) SWIG_fail;
14685 {
14686 PyThreadState* __tstate = wxPyBeginAllowThreads();
14687 result = (bool)(arg1)->GetEvtHandlerEnabled();
14688
14689 wxPyEndAllowThreads(__tstate);
14690 if (PyErr_Occurred()) SWIG_fail;
14691 }
14692 {
14693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14694 }
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj;
14703 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14704 bool arg2 ;
14705 PyObject * obj0 = 0 ;
14706 PyObject * obj1 = 0 ;
14707 char *kwnames[] = {
14708 (char *) "self",(char *) "enabled", NULL
14709 };
14710
14711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14713 if (SWIG_arg_fail(1)) SWIG_fail;
14714 {
14715 arg2 = (bool)(SWIG_As_bool(obj1));
14716 if (SWIG_arg_fail(2)) SWIG_fail;
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 (arg1)->SetEvtHandlerEnabled(arg2);
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 Py_INCREF(Py_None); resultobj = Py_None;
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14733 PyObject *resultobj;
14734 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14735 wxEvent *arg2 = 0 ;
14736 bool result;
14737 PyObject * obj0 = 0 ;
14738 PyObject * obj1 = 0 ;
14739 char *kwnames[] = {
14740 (char *) "self",(char *) "event", NULL
14741 };
14742
14743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14745 if (SWIG_arg_fail(1)) SWIG_fail;
14746 {
14747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14748 if (SWIG_arg_fail(2)) SWIG_fail;
14749 if (arg2 == NULL) {
14750 SWIG_null_ref("wxEvent");
14751 }
14752 if (SWIG_arg_fail(2)) SWIG_fail;
14753 }
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 result = (bool)(arg1)->ProcessEvent(*arg2);
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 {
14762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14763 }
14764 return resultobj;
14765 fail:
14766 return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14773 wxEvent *arg2 = 0 ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 char *kwnames[] = {
14777 (char *) "self",(char *) "event", NULL
14778 };
14779
14780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14782 if (SWIG_arg_fail(1)) SWIG_fail;
14783 {
14784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14785 if (SWIG_arg_fail(2)) SWIG_fail;
14786 if (arg2 == NULL) {
14787 SWIG_null_ref("wxEvent");
14788 }
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 (arg1)->AddPendingEvent(*arg2);
14794
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 Py_INCREF(Py_None); resultobj = Py_None;
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14808 PyObject * obj0 = 0 ;
14809 char *kwnames[] = {
14810 (char *) "self", NULL
14811 };
14812
14813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14815 if (SWIG_arg_fail(1)) SWIG_fail;
14816 {
14817 PyThreadState* __tstate = wxPyBeginAllowThreads();
14818 (arg1)->ProcessPendingEvents();
14819
14820 wxPyEndAllowThreads(__tstate);
14821 if (PyErr_Occurred()) SWIG_fail;
14822 }
14823 Py_INCREF(Py_None); resultobj = Py_None;
14824 return resultobj;
14825 fail:
14826 return NULL;
14827 }
14828
14829
14830 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14831 PyObject *resultobj;
14832 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14833 int arg2 ;
14834 int arg3 ;
14835 int arg4 ;
14836 PyObject *arg5 = (PyObject *) 0 ;
14837 PyObject * obj0 = 0 ;
14838 PyObject * obj1 = 0 ;
14839 PyObject * obj2 = 0 ;
14840 PyObject * obj3 = 0 ;
14841 PyObject * obj4 = 0 ;
14842 char *kwnames[] = {
14843 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14844 };
14845
14846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14848 if (SWIG_arg_fail(1)) SWIG_fail;
14849 {
14850 arg2 = (int)(SWIG_As_int(obj1));
14851 if (SWIG_arg_fail(2)) SWIG_fail;
14852 }
14853 {
14854 arg3 = (int)(SWIG_As_int(obj2));
14855 if (SWIG_arg_fail(3)) SWIG_fail;
14856 }
14857 {
14858 arg4 = (int)(SWIG_As_int(obj3));
14859 if (SWIG_arg_fail(4)) SWIG_fail;
14860 }
14861 arg5 = obj4;
14862 {
14863 PyThreadState* __tstate = wxPyBeginAllowThreads();
14864 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14865
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 Py_INCREF(Py_None); resultobj = Py_None;
14870 return resultobj;
14871 fail:
14872 return NULL;
14873 }
14874
14875
14876 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj;
14878 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14879 int arg2 ;
14880 int arg3 = (int) -1 ;
14881 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14882 bool result;
14883 PyObject * obj0 = 0 ;
14884 PyObject * obj1 = 0 ;
14885 PyObject * obj2 = 0 ;
14886 PyObject * obj3 = 0 ;
14887 char *kwnames[] = {
14888 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14889 };
14890
14891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14893 if (SWIG_arg_fail(1)) SWIG_fail;
14894 {
14895 arg2 = (int)(SWIG_As_int(obj1));
14896 if (SWIG_arg_fail(2)) SWIG_fail;
14897 }
14898 if (obj2) {
14899 {
14900 arg3 = (int)(SWIG_As_int(obj2));
14901 if (SWIG_arg_fail(3)) SWIG_fail;
14902 }
14903 }
14904 if (obj3) {
14905 {
14906 arg4 = (wxEventType)(SWIG_As_int(obj3));
14907 if (SWIG_arg_fail(4)) SWIG_fail;
14908 }
14909 }
14910 {
14911 PyThreadState* __tstate = wxPyBeginAllowThreads();
14912 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14913
14914 wxPyEndAllowThreads(__tstate);
14915 if (PyErr_Occurred()) SWIG_fail;
14916 }
14917 {
14918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14919 }
14920 return resultobj;
14921 fail:
14922 return NULL;
14923 }
14924
14925
14926 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14927 PyObject *resultobj;
14928 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14929 PyObject *arg2 = (PyObject *) 0 ;
14930 bool arg3 = (bool) true ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 PyObject * obj2 = 0 ;
14934 char *kwnames[] = {
14935 (char *) "self",(char *) "_self",(char *) "incref", NULL
14936 };
14937
14938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14940 if (SWIG_arg_fail(1)) SWIG_fail;
14941 arg2 = obj1;
14942 if (obj2) {
14943 {
14944 arg3 = (bool)(SWIG_As_bool(obj2));
14945 if (SWIG_arg_fail(3)) SWIG_fail;
14946 }
14947 }
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14951
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 Py_INCREF(Py_None); resultobj = Py_None;
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14963 PyObject *obj;
14964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14965 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14966 Py_INCREF(obj);
14967 return Py_BuildValue((char *)"");
14968 }
14969 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj;
14971 wxEventType result;
14972 char *kwnames[] = {
14973 NULL
14974 };
14975
14976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (wxEventType)wxNewEventType();
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 {
14985 resultobj = SWIG_From_int((int)(result));
14986 }
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj;
14995 wxEvent *arg1 = (wxEvent *) 0 ;
14996 PyObject * obj0 = 0 ;
14997 char *kwnames[] = {
14998 (char *) "self", NULL
14999 };
15000
15001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15003 if (SWIG_arg_fail(1)) SWIG_fail;
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 delete arg1;
15007
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 Py_INCREF(Py_None); resultobj = Py_None;
15012 return resultobj;
15013 fail:
15014 return NULL;
15015 }
15016
15017
15018 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15019 PyObject *resultobj;
15020 wxEvent *arg1 = (wxEvent *) 0 ;
15021 wxEventType arg2 ;
15022 PyObject * obj0 = 0 ;
15023 PyObject * obj1 = 0 ;
15024 char *kwnames[] = {
15025 (char *) "self",(char *) "typ", NULL
15026 };
15027
15028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15030 if (SWIG_arg_fail(1)) SWIG_fail;
15031 {
15032 arg2 = (wxEventType)(SWIG_As_int(obj1));
15033 if (SWIG_arg_fail(2)) SWIG_fail;
15034 }
15035 {
15036 PyThreadState* __tstate = wxPyBeginAllowThreads();
15037 (arg1)->SetEventType(arg2);
15038
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 Py_INCREF(Py_None); resultobj = Py_None;
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15050 PyObject *resultobj;
15051 wxEvent *arg1 = (wxEvent *) 0 ;
15052 wxEventType result;
15053 PyObject * obj0 = 0 ;
15054 char *kwnames[] = {
15055 (char *) "self", NULL
15056 };
15057
15058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15060 if (SWIG_arg_fail(1)) SWIG_fail;
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15064
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 {
15069 resultobj = SWIG_From_int((int)(result));
15070 }
15071 return resultobj;
15072 fail:
15073 return NULL;
15074 }
15075
15076
15077 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15078 PyObject *resultobj;
15079 wxEvent *arg1 = (wxEvent *) 0 ;
15080 wxObject *result;
15081 PyObject * obj0 = 0 ;
15082 char *kwnames[] = {
15083 (char *) "self", NULL
15084 };
15085
15086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15088 if (SWIG_arg_fail(1)) SWIG_fail;
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15092
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 {
15097 resultobj = wxPyMake_wxObject(result, 0);
15098 }
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj;
15107 wxEvent *arg1 = (wxEvent *) 0 ;
15108 wxObject *arg2 = (wxObject *) 0 ;
15109 PyObject * obj0 = 0 ;
15110 PyObject * obj1 = 0 ;
15111 char *kwnames[] = {
15112 (char *) "self",(char *) "obj", NULL
15113 };
15114
15115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15117 if (SWIG_arg_fail(1)) SWIG_fail;
15118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15119 if (SWIG_arg_fail(2)) SWIG_fail;
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 (arg1)->SetEventObject(arg2);
15123
15124 wxPyEndAllowThreads(__tstate);
15125 if (PyErr_Occurred()) SWIG_fail;
15126 }
15127 Py_INCREF(Py_None); resultobj = Py_None;
15128 return resultobj;
15129 fail:
15130 return NULL;
15131 }
15132
15133
15134 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15135 PyObject *resultobj;
15136 wxEvent *arg1 = (wxEvent *) 0 ;
15137 long result;
15138 PyObject * obj0 = 0 ;
15139 char *kwnames[] = {
15140 (char *) "self", NULL
15141 };
15142
15143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15145 if (SWIG_arg_fail(1)) SWIG_fail;
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15149
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 {
15154 resultobj = SWIG_From_long((long)(result));
15155 }
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15163 PyObject *resultobj;
15164 wxEvent *arg1 = (wxEvent *) 0 ;
15165 long arg2 = (long) 0 ;
15166 PyObject * obj0 = 0 ;
15167 PyObject * obj1 = 0 ;
15168 char *kwnames[] = {
15169 (char *) "self",(char *) "ts", NULL
15170 };
15171
15172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15174 if (SWIG_arg_fail(1)) SWIG_fail;
15175 if (obj1) {
15176 {
15177 arg2 = (long)(SWIG_As_long(obj1));
15178 if (SWIG_arg_fail(2)) SWIG_fail;
15179 }
15180 }
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 (arg1)->SetTimestamp(arg2);
15184
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 Py_INCREF(Py_None); resultobj = Py_None;
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15196 PyObject *resultobj;
15197 wxEvent *arg1 = (wxEvent *) 0 ;
15198 int result;
15199 PyObject * obj0 = 0 ;
15200 char *kwnames[] = {
15201 (char *) "self", NULL
15202 };
15203
15204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15206 if (SWIG_arg_fail(1)) SWIG_fail;
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (int)((wxEvent const *)arg1)->GetId();
15210
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 {
15215 resultobj = SWIG_From_int((int)(result));
15216 }
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15224 PyObject *resultobj;
15225 wxEvent *arg1 = (wxEvent *) 0 ;
15226 int arg2 ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 char *kwnames[] = {
15230 (char *) "self",(char *) "Id", NULL
15231 };
15232
15233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15235 if (SWIG_arg_fail(1)) SWIG_fail;
15236 {
15237 arg2 = (int)(SWIG_As_int(obj1));
15238 if (SWIG_arg_fail(2)) SWIG_fail;
15239 }
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 (arg1)->SetId(arg2);
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 Py_INCREF(Py_None); resultobj = Py_None;
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15255 PyObject *resultobj;
15256 wxEvent *arg1 = (wxEvent *) 0 ;
15257 bool result;
15258 PyObject * obj0 = 0 ;
15259 char *kwnames[] = {
15260 (char *) "self", NULL
15261 };
15262
15263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15265 if (SWIG_arg_fail(1)) SWIG_fail;
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15269
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 {
15274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15275 }
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15283 PyObject *resultobj;
15284 wxEvent *arg1 = (wxEvent *) 0 ;
15285 bool arg2 = (bool) true ;
15286 PyObject * obj0 = 0 ;
15287 PyObject * obj1 = 0 ;
15288 char *kwnames[] = {
15289 (char *) "self",(char *) "skip", NULL
15290 };
15291
15292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(1)) SWIG_fail;
15295 if (obj1) {
15296 {
15297 arg2 = (bool)(SWIG_As_bool(obj1));
15298 if (SWIG_arg_fail(2)) SWIG_fail;
15299 }
15300 }
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 (arg1)->Skip(arg2);
15304
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 Py_INCREF(Py_None); resultobj = Py_None;
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15316 PyObject *resultobj;
15317 wxEvent *arg1 = (wxEvent *) 0 ;
15318 bool result;
15319 PyObject * obj0 = 0 ;
15320 char *kwnames[] = {
15321 (char *) "self", NULL
15322 };
15323
15324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15326 if (SWIG_arg_fail(1)) SWIG_fail;
15327 {
15328 PyThreadState* __tstate = wxPyBeginAllowThreads();
15329 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15330
15331 wxPyEndAllowThreads(__tstate);
15332 if (PyErr_Occurred()) SWIG_fail;
15333 }
15334 {
15335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15336 }
15337 return resultobj;
15338 fail:
15339 return NULL;
15340 }
15341
15342
15343 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15344 PyObject *resultobj;
15345 wxEvent *arg1 = (wxEvent *) 0 ;
15346 bool result;
15347 PyObject * obj0 = 0 ;
15348 char *kwnames[] = {
15349 (char *) "self", NULL
15350 };
15351
15352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15354 if (SWIG_arg_fail(1)) SWIG_fail;
15355 {
15356 PyThreadState* __tstate = wxPyBeginAllowThreads();
15357 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15358
15359 wxPyEndAllowThreads(__tstate);
15360 if (PyErr_Occurred()) SWIG_fail;
15361 }
15362 {
15363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15364 }
15365 return resultobj;
15366 fail:
15367 return NULL;
15368 }
15369
15370
15371 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15372 PyObject *resultobj;
15373 wxEvent *arg1 = (wxEvent *) 0 ;
15374 int result;
15375 PyObject * obj0 = 0 ;
15376 char *kwnames[] = {
15377 (char *) "self", NULL
15378 };
15379
15380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 {
15384 PyThreadState* __tstate = wxPyBeginAllowThreads();
15385 result = (int)(arg1)->StopPropagation();
15386
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 {
15391 resultobj = SWIG_From_int((int)(result));
15392 }
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15400 PyObject *resultobj;
15401 wxEvent *arg1 = (wxEvent *) 0 ;
15402 int arg2 ;
15403 PyObject * obj0 = 0 ;
15404 PyObject * obj1 = 0 ;
15405 char *kwnames[] = {
15406 (char *) "self",(char *) "propagationLevel", NULL
15407 };
15408
15409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15411 if (SWIG_arg_fail(1)) SWIG_fail;
15412 {
15413 arg2 = (int)(SWIG_As_int(obj1));
15414 if (SWIG_arg_fail(2)) SWIG_fail;
15415 }
15416 {
15417 PyThreadState* __tstate = wxPyBeginAllowThreads();
15418 (arg1)->ResumePropagation(arg2);
15419
15420 wxPyEndAllowThreads(__tstate);
15421 if (PyErr_Occurred()) SWIG_fail;
15422 }
15423 Py_INCREF(Py_None); resultobj = Py_None;
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxEvent *arg1 = (wxEvent *) 0 ;
15433 wxEvent *result;
15434 PyObject * obj0 = 0 ;
15435 char *kwnames[] = {
15436 (char *) "self", NULL
15437 };
15438
15439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15441 if (SWIG_arg_fail(1)) SWIG_fail;
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 result = (wxEvent *)(arg1)->Clone();
15445
15446 wxPyEndAllowThreads(__tstate);
15447 if (PyErr_Occurred()) SWIG_fail;
15448 }
15449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15450 return resultobj;
15451 fail:
15452 return NULL;
15453 }
15454
15455
15456 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15457 PyObject *obj;
15458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15459 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15460 Py_INCREF(obj);
15461 return Py_BuildValue((char *)"");
15462 }
15463 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15464 PyObject *resultobj;
15465 wxEvent *arg1 = 0 ;
15466 wxPropagationDisabler *result;
15467 PyObject * obj0 = 0 ;
15468 char *kwnames[] = {
15469 (char *) "event", NULL
15470 };
15471
15472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15473 {
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 if (arg1 == NULL) {
15477 SWIG_null_ref("wxEvent");
15478 }
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 }
15481 {
15482 PyThreadState* __tstate = wxPyBeginAllowThreads();
15483 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15484
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15496 PyObject *resultobj;
15497 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15498 PyObject * obj0 = 0 ;
15499 char *kwnames[] = {
15500 (char *) "self", NULL
15501 };
15502
15503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15505 if (SWIG_arg_fail(1)) SWIG_fail;
15506 {
15507 PyThreadState* __tstate = wxPyBeginAllowThreads();
15508 delete arg1;
15509
15510 wxPyEndAllowThreads(__tstate);
15511 if (PyErr_Occurred()) SWIG_fail;
15512 }
15513 Py_INCREF(Py_None); resultobj = Py_None;
15514 return resultobj;
15515 fail:
15516 return NULL;
15517 }
15518
15519
15520 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15521 PyObject *obj;
15522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15523 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15524 Py_INCREF(obj);
15525 return Py_BuildValue((char *)"");
15526 }
15527 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15528 PyObject *resultobj;
15529 wxEvent *arg1 = 0 ;
15530 wxPropagateOnce *result;
15531 PyObject * obj0 = 0 ;
15532 char *kwnames[] = {
15533 (char *) "event", NULL
15534 };
15535
15536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15537 {
15538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15539 if (SWIG_arg_fail(1)) SWIG_fail;
15540 if (arg1 == NULL) {
15541 SWIG_null_ref("wxEvent");
15542 }
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 }
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15548
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj;
15561 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15562 PyObject * obj0 = 0 ;
15563 char *kwnames[] = {
15564 (char *) "self", NULL
15565 };
15566
15567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15569 if (SWIG_arg_fail(1)) SWIG_fail;
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 delete arg1;
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 Py_INCREF(Py_None); resultobj = Py_None;
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15585 PyObject *obj;
15586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15587 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15588 Py_INCREF(obj);
15589 return Py_BuildValue((char *)"");
15590 }
15591 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj;
15593 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15594 int arg2 = (int) 0 ;
15595 wxCommandEvent *result;
15596 PyObject * obj0 = 0 ;
15597 PyObject * obj1 = 0 ;
15598 char *kwnames[] = {
15599 (char *) "commandType",(char *) "winid", NULL
15600 };
15601
15602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15603 if (obj0) {
15604 {
15605 arg1 = (wxEventType)(SWIG_As_int(obj0));
15606 if (SWIG_arg_fail(1)) SWIG_fail;
15607 }
15608 }
15609 if (obj1) {
15610 {
15611 arg2 = (int)(SWIG_As_int(obj1));
15612 if (SWIG_arg_fail(2)) SWIG_fail;
15613 }
15614 }
15615 {
15616 PyThreadState* __tstate = wxPyBeginAllowThreads();
15617 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15618
15619 wxPyEndAllowThreads(__tstate);
15620 if (PyErr_Occurred()) SWIG_fail;
15621 }
15622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15623 return resultobj;
15624 fail:
15625 return NULL;
15626 }
15627
15628
15629 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15630 PyObject *resultobj;
15631 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15632 int result;
15633 PyObject * obj0 = 0 ;
15634 char *kwnames[] = {
15635 (char *) "self", NULL
15636 };
15637
15638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15640 if (SWIG_arg_fail(1)) SWIG_fail;
15641 {
15642 PyThreadState* __tstate = wxPyBeginAllowThreads();
15643 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15644
15645 wxPyEndAllowThreads(__tstate);
15646 if (PyErr_Occurred()) SWIG_fail;
15647 }
15648 {
15649 resultobj = SWIG_From_int((int)(result));
15650 }
15651 return resultobj;
15652 fail:
15653 return NULL;
15654 }
15655
15656
15657 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15658 PyObject *resultobj;
15659 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15660 wxString *arg2 = 0 ;
15661 bool temp2 = false ;
15662 PyObject * obj0 = 0 ;
15663 PyObject * obj1 = 0 ;
15664 char *kwnames[] = {
15665 (char *) "self",(char *) "s", NULL
15666 };
15667
15668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15670 if (SWIG_arg_fail(1)) SWIG_fail;
15671 {
15672 arg2 = wxString_in_helper(obj1);
15673 if (arg2 == NULL) SWIG_fail;
15674 temp2 = true;
15675 }
15676 {
15677 PyThreadState* __tstate = wxPyBeginAllowThreads();
15678 (arg1)->SetString((wxString const &)*arg2);
15679
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 Py_INCREF(Py_None); resultobj = Py_None;
15684 {
15685 if (temp2)
15686 delete arg2;
15687 }
15688 return resultobj;
15689 fail:
15690 {
15691 if (temp2)
15692 delete arg2;
15693 }
15694 return NULL;
15695 }
15696
15697
15698 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15699 PyObject *resultobj;
15700 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15701 wxString result;
15702 PyObject * obj0 = 0 ;
15703 char *kwnames[] = {
15704 (char *) "self", NULL
15705 };
15706
15707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15709 if (SWIG_arg_fail(1)) SWIG_fail;
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = ((wxCommandEvent const *)arg1)->GetString();
15713
15714 wxPyEndAllowThreads(__tstate);
15715 if (PyErr_Occurred()) SWIG_fail;
15716 }
15717 {
15718 #if wxUSE_UNICODE
15719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15720 #else
15721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15722 #endif
15723 }
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15731 PyObject *resultobj;
15732 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15733 bool result;
15734 PyObject * obj0 = 0 ;
15735 char *kwnames[] = {
15736 (char *) "self", NULL
15737 };
15738
15739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15741 if (SWIG_arg_fail(1)) SWIG_fail;
15742 {
15743 PyThreadState* __tstate = wxPyBeginAllowThreads();
15744 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15745
15746 wxPyEndAllowThreads(__tstate);
15747 if (PyErr_Occurred()) SWIG_fail;
15748 }
15749 {
15750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15751 }
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15759 PyObject *resultobj;
15760 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15761 bool result;
15762 PyObject * obj0 = 0 ;
15763 char *kwnames[] = {
15764 (char *) "self", NULL
15765 };
15766
15767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15769 if (SWIG_arg_fail(1)) SWIG_fail;
15770 {
15771 PyThreadState* __tstate = wxPyBeginAllowThreads();
15772 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15773
15774 wxPyEndAllowThreads(__tstate);
15775 if (PyErr_Occurred()) SWIG_fail;
15776 }
15777 {
15778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15779 }
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15787 PyObject *resultobj;
15788 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15789 long arg2 ;
15790 PyObject * obj0 = 0 ;
15791 PyObject * obj1 = 0 ;
15792 char *kwnames[] = {
15793 (char *) "self",(char *) "extraLong", NULL
15794 };
15795
15796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15798 if (SWIG_arg_fail(1)) SWIG_fail;
15799 {
15800 arg2 = (long)(SWIG_As_long(obj1));
15801 if (SWIG_arg_fail(2)) SWIG_fail;
15802 }
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 (arg1)->SetExtraLong(arg2);
15806
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 Py_INCREF(Py_None); resultobj = Py_None;
15811 return resultobj;
15812 fail:
15813 return NULL;
15814 }
15815
15816
15817 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15818 PyObject *resultobj;
15819 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15820 long result;
15821 PyObject * obj0 = 0 ;
15822 char *kwnames[] = {
15823 (char *) "self", NULL
15824 };
15825
15826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15828 if (SWIG_arg_fail(1)) SWIG_fail;
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15832
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 {
15837 resultobj = SWIG_From_long((long)(result));
15838 }
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj;
15847 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15848 int arg2 ;
15849 PyObject * obj0 = 0 ;
15850 PyObject * obj1 = 0 ;
15851 char *kwnames[] = {
15852 (char *) "self",(char *) "i", NULL
15853 };
15854
15855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15857 if (SWIG_arg_fail(1)) SWIG_fail;
15858 {
15859 arg2 = (int)(SWIG_As_int(obj1));
15860 if (SWIG_arg_fail(2)) SWIG_fail;
15861 }
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 (arg1)->SetInt(arg2);
15865
15866 wxPyEndAllowThreads(__tstate);
15867 if (PyErr_Occurred()) SWIG_fail;
15868 }
15869 Py_INCREF(Py_None); resultobj = Py_None;
15870 return resultobj;
15871 fail:
15872 return NULL;
15873 }
15874
15875
15876 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15877 PyObject *resultobj;
15878 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15879 long result;
15880 PyObject * obj0 = 0 ;
15881 char *kwnames[] = {
15882 (char *) "self", NULL
15883 };
15884
15885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15887 if (SWIG_arg_fail(1)) SWIG_fail;
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15891
15892 wxPyEndAllowThreads(__tstate);
15893 if (PyErr_Occurred()) SWIG_fail;
15894 }
15895 {
15896 resultobj = SWIG_From_long((long)(result));
15897 }
15898 return resultobj;
15899 fail:
15900 return NULL;
15901 }
15902
15903
15904 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15905 PyObject *resultobj;
15906 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15907 wxEvent *result;
15908 PyObject * obj0 = 0 ;
15909 char *kwnames[] = {
15910 (char *) "self", NULL
15911 };
15912
15913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15915 if (SWIG_arg_fail(1)) SWIG_fail;
15916 {
15917 PyThreadState* __tstate = wxPyBeginAllowThreads();
15918 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15919
15920 wxPyEndAllowThreads(__tstate);
15921 if (PyErr_Occurred()) SWIG_fail;
15922 }
15923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15924 return resultobj;
15925 fail:
15926 return NULL;
15927 }
15928
15929
15930 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15931 PyObject *obj;
15932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15933 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15934 Py_INCREF(obj);
15935 return Py_BuildValue((char *)"");
15936 }
15937 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15938 PyObject *resultobj;
15939 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15940 int arg2 = (int) 0 ;
15941 wxNotifyEvent *result;
15942 PyObject * obj0 = 0 ;
15943 PyObject * obj1 = 0 ;
15944 char *kwnames[] = {
15945 (char *) "commandType",(char *) "winid", NULL
15946 };
15947
15948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15949 if (obj0) {
15950 {
15951 arg1 = (wxEventType)(SWIG_As_int(obj0));
15952 if (SWIG_arg_fail(1)) SWIG_fail;
15953 }
15954 }
15955 if (obj1) {
15956 {
15957 arg2 = (int)(SWIG_As_int(obj1));
15958 if (SWIG_arg_fail(2)) SWIG_fail;
15959 }
15960 }
15961 {
15962 PyThreadState* __tstate = wxPyBeginAllowThreads();
15963 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15964
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj;
15977 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15978 PyObject * obj0 = 0 ;
15979 char *kwnames[] = {
15980 (char *) "self", NULL
15981 };
15982
15983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15985 if (SWIG_arg_fail(1)) SWIG_fail;
15986 {
15987 PyThreadState* __tstate = wxPyBeginAllowThreads();
15988 (arg1)->Veto();
15989
15990 wxPyEndAllowThreads(__tstate);
15991 if (PyErr_Occurred()) SWIG_fail;
15992 }
15993 Py_INCREF(Py_None); resultobj = Py_None;
15994 return resultobj;
15995 fail:
15996 return NULL;
15997 }
15998
15999
16000 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16001 PyObject *resultobj;
16002 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16003 PyObject * obj0 = 0 ;
16004 char *kwnames[] = {
16005 (char *) "self", NULL
16006 };
16007
16008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16010 if (SWIG_arg_fail(1)) SWIG_fail;
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 (arg1)->Allow();
16014
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 Py_INCREF(Py_None); resultobj = Py_None;
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16026 PyObject *resultobj;
16027 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16028 bool result;
16029 PyObject * obj0 = 0 ;
16030 char *kwnames[] = {
16031 (char *) "self", NULL
16032 };
16033
16034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16036 if (SWIG_arg_fail(1)) SWIG_fail;
16037 {
16038 PyThreadState* __tstate = wxPyBeginAllowThreads();
16039 result = (bool)(arg1)->IsAllowed();
16040
16041 wxPyEndAllowThreads(__tstate);
16042 if (PyErr_Occurred()) SWIG_fail;
16043 }
16044 {
16045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16046 }
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16054 PyObject *obj;
16055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16056 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16057 Py_INCREF(obj);
16058 return Py_BuildValue((char *)"");
16059 }
16060 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16061 PyObject *resultobj;
16062 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16063 int arg2 = (int) 0 ;
16064 int arg3 = (int) 0 ;
16065 int arg4 = (int) 0 ;
16066 wxScrollEvent *result;
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 PyObject * obj2 = 0 ;
16070 PyObject * obj3 = 0 ;
16071 char *kwnames[] = {
16072 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16073 };
16074
16075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16076 if (obj0) {
16077 {
16078 arg1 = (wxEventType)(SWIG_As_int(obj0));
16079 if (SWIG_arg_fail(1)) SWIG_fail;
16080 }
16081 }
16082 if (obj1) {
16083 {
16084 arg2 = (int)(SWIG_As_int(obj1));
16085 if (SWIG_arg_fail(2)) SWIG_fail;
16086 }
16087 }
16088 if (obj2) {
16089 {
16090 arg3 = (int)(SWIG_As_int(obj2));
16091 if (SWIG_arg_fail(3)) SWIG_fail;
16092 }
16093 }
16094 if (obj3) {
16095 {
16096 arg4 = (int)(SWIG_As_int(obj3));
16097 if (SWIG_arg_fail(4)) SWIG_fail;
16098 }
16099 }
16100 {
16101 PyThreadState* __tstate = wxPyBeginAllowThreads();
16102 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16103
16104 wxPyEndAllowThreads(__tstate);
16105 if (PyErr_Occurred()) SWIG_fail;
16106 }
16107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16108 return resultobj;
16109 fail:
16110 return NULL;
16111 }
16112
16113
16114 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16115 PyObject *resultobj;
16116 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16117 int result;
16118 PyObject * obj0 = 0 ;
16119 char *kwnames[] = {
16120 (char *) "self", NULL
16121 };
16122
16123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16125 if (SWIG_arg_fail(1)) SWIG_fail;
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16129
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 {
16134 resultobj = SWIG_From_int((int)(result));
16135 }
16136 return resultobj;
16137 fail:
16138 return NULL;
16139 }
16140
16141
16142 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16143 PyObject *resultobj;
16144 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16145 int result;
16146 PyObject * obj0 = 0 ;
16147 char *kwnames[] = {
16148 (char *) "self", NULL
16149 };
16150
16151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16153 if (SWIG_arg_fail(1)) SWIG_fail;
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16157
16158 wxPyEndAllowThreads(__tstate);
16159 if (PyErr_Occurred()) SWIG_fail;
16160 }
16161 {
16162 resultobj = SWIG_From_int((int)(result));
16163 }
16164 return resultobj;
16165 fail:
16166 return NULL;
16167 }
16168
16169
16170 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16171 PyObject *resultobj;
16172 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16173 int arg2 ;
16174 PyObject * obj0 = 0 ;
16175 PyObject * obj1 = 0 ;
16176 char *kwnames[] = {
16177 (char *) "self",(char *) "orient", NULL
16178 };
16179
16180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16182 if (SWIG_arg_fail(1)) SWIG_fail;
16183 {
16184 arg2 = (int)(SWIG_As_int(obj1));
16185 if (SWIG_arg_fail(2)) SWIG_fail;
16186 }
16187 {
16188 PyThreadState* __tstate = wxPyBeginAllowThreads();
16189 (arg1)->SetOrientation(arg2);
16190
16191 wxPyEndAllowThreads(__tstate);
16192 if (PyErr_Occurred()) SWIG_fail;
16193 }
16194 Py_INCREF(Py_None); resultobj = Py_None;
16195 return resultobj;
16196 fail:
16197 return NULL;
16198 }
16199
16200
16201 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16202 PyObject *resultobj;
16203 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16204 int arg2 ;
16205 PyObject * obj0 = 0 ;
16206 PyObject * obj1 = 0 ;
16207 char *kwnames[] = {
16208 (char *) "self",(char *) "pos", NULL
16209 };
16210
16211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16213 if (SWIG_arg_fail(1)) SWIG_fail;
16214 {
16215 arg2 = (int)(SWIG_As_int(obj1));
16216 if (SWIG_arg_fail(2)) SWIG_fail;
16217 }
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 (arg1)->SetPosition(arg2);
16221
16222 wxPyEndAllowThreads(__tstate);
16223 if (PyErr_Occurred()) SWIG_fail;
16224 }
16225 Py_INCREF(Py_None); resultobj = Py_None;
16226 return resultobj;
16227 fail:
16228 return NULL;
16229 }
16230
16231
16232 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16233 PyObject *obj;
16234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16235 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16236 Py_INCREF(obj);
16237 return Py_BuildValue((char *)"");
16238 }
16239 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16240 PyObject *resultobj;
16241 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16242 int arg2 = (int) 0 ;
16243 int arg3 = (int) 0 ;
16244 wxScrollWinEvent *result;
16245 PyObject * obj0 = 0 ;
16246 PyObject * obj1 = 0 ;
16247 PyObject * obj2 = 0 ;
16248 char *kwnames[] = {
16249 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16250 };
16251
16252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16253 if (obj0) {
16254 {
16255 arg1 = (wxEventType)(SWIG_As_int(obj0));
16256 if (SWIG_arg_fail(1)) SWIG_fail;
16257 }
16258 }
16259 if (obj1) {
16260 {
16261 arg2 = (int)(SWIG_As_int(obj1));
16262 if (SWIG_arg_fail(2)) SWIG_fail;
16263 }
16264 }
16265 if (obj2) {
16266 {
16267 arg3 = (int)(SWIG_As_int(obj2));
16268 if (SWIG_arg_fail(3)) SWIG_fail;
16269 }
16270 }
16271 {
16272 PyThreadState* __tstate = wxPyBeginAllowThreads();
16273 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16274
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj;
16287 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16288 int result;
16289 PyObject * obj0 = 0 ;
16290 char *kwnames[] = {
16291 (char *) "self", NULL
16292 };
16293
16294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16296 if (SWIG_arg_fail(1)) SWIG_fail;
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16300
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 resultobj = SWIG_From_int((int)(result));
16306 }
16307 return resultobj;
16308 fail:
16309 return NULL;
16310 }
16311
16312
16313 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16314 PyObject *resultobj;
16315 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16316 int result;
16317 PyObject * obj0 = 0 ;
16318 char *kwnames[] = {
16319 (char *) "self", NULL
16320 };
16321
16322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16324 if (SWIG_arg_fail(1)) SWIG_fail;
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16328
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 {
16333 resultobj = SWIG_From_int((int)(result));
16334 }
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj;
16343 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16344 int arg2 ;
16345 PyObject * obj0 = 0 ;
16346 PyObject * obj1 = 0 ;
16347 char *kwnames[] = {
16348 (char *) "self",(char *) "orient", NULL
16349 };
16350
16351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16353 if (SWIG_arg_fail(1)) SWIG_fail;
16354 {
16355 arg2 = (int)(SWIG_As_int(obj1));
16356 if (SWIG_arg_fail(2)) SWIG_fail;
16357 }
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 (arg1)->SetOrientation(arg2);
16361
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 Py_INCREF(Py_None); resultobj = Py_None;
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj;
16374 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16375 int arg2 ;
16376 PyObject * obj0 = 0 ;
16377 PyObject * obj1 = 0 ;
16378 char *kwnames[] = {
16379 (char *) "self",(char *) "pos", NULL
16380 };
16381
16382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16384 if (SWIG_arg_fail(1)) SWIG_fail;
16385 {
16386 arg2 = (int)(SWIG_As_int(obj1));
16387 if (SWIG_arg_fail(2)) SWIG_fail;
16388 }
16389 {
16390 PyThreadState* __tstate = wxPyBeginAllowThreads();
16391 (arg1)->SetPosition(arg2);
16392
16393 wxPyEndAllowThreads(__tstate);
16394 if (PyErr_Occurred()) SWIG_fail;
16395 }
16396 Py_INCREF(Py_None); resultobj = Py_None;
16397 return resultobj;
16398 fail:
16399 return NULL;
16400 }
16401
16402
16403 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16404 PyObject *obj;
16405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16406 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16407 Py_INCREF(obj);
16408 return Py_BuildValue((char *)"");
16409 }
16410 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16411 PyObject *resultobj;
16412 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16413 wxMouseEvent *result;
16414 PyObject * obj0 = 0 ;
16415 char *kwnames[] = {
16416 (char *) "mouseType", NULL
16417 };
16418
16419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16420 if (obj0) {
16421 {
16422 arg1 = (wxEventType)(SWIG_As_int(obj0));
16423 if (SWIG_arg_fail(1)) SWIG_fail;
16424 }
16425 }
16426 {
16427 PyThreadState* __tstate = wxPyBeginAllowThreads();
16428 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16429
16430 wxPyEndAllowThreads(__tstate);
16431 if (PyErr_Occurred()) SWIG_fail;
16432 }
16433 {
16434 resultobj = wxPyMake_wxObject(result, 1);
16435 }
16436 return resultobj;
16437 fail:
16438 return NULL;
16439 }
16440
16441
16442 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16443 PyObject *resultobj;
16444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16445 bool result;
16446 PyObject * obj0 = 0 ;
16447 char *kwnames[] = {
16448 (char *) "self", NULL
16449 };
16450
16451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16453 if (SWIG_arg_fail(1)) SWIG_fail;
16454 {
16455 PyThreadState* __tstate = wxPyBeginAllowThreads();
16456 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16457
16458 wxPyEndAllowThreads(__tstate);
16459 if (PyErr_Occurred()) SWIG_fail;
16460 }
16461 {
16462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16463 }
16464 return resultobj;
16465 fail:
16466 return NULL;
16467 }
16468
16469
16470 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16471 PyObject *resultobj;
16472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16473 int arg2 = (int) wxMOUSE_BTN_ANY ;
16474 bool result;
16475 PyObject * obj0 = 0 ;
16476 PyObject * obj1 = 0 ;
16477 char *kwnames[] = {
16478 (char *) "self",(char *) "but", NULL
16479 };
16480
16481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16483 if (SWIG_arg_fail(1)) SWIG_fail;
16484 if (obj1) {
16485 {
16486 arg2 = (int)(SWIG_As_int(obj1));
16487 if (SWIG_arg_fail(2)) SWIG_fail;
16488 }
16489 }
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16493
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 {
16498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16499 }
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj;
16508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16509 int arg2 = (int) wxMOUSE_BTN_ANY ;
16510 bool result;
16511 PyObject * obj0 = 0 ;
16512 PyObject * obj1 = 0 ;
16513 char *kwnames[] = {
16514 (char *) "self",(char *) "but", NULL
16515 };
16516
16517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16519 if (SWIG_arg_fail(1)) SWIG_fail;
16520 if (obj1) {
16521 {
16522 arg2 = (int)(SWIG_As_int(obj1));
16523 if (SWIG_arg_fail(2)) SWIG_fail;
16524 }
16525 }
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16529
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 {
16534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16535 }
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj;
16544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16545 int arg2 = (int) wxMOUSE_BTN_ANY ;
16546 bool result;
16547 PyObject * obj0 = 0 ;
16548 PyObject * obj1 = 0 ;
16549 char *kwnames[] = {
16550 (char *) "self",(char *) "but", NULL
16551 };
16552
16553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16555 if (SWIG_arg_fail(1)) SWIG_fail;
16556 if (obj1) {
16557 {
16558 arg2 = (int)(SWIG_As_int(obj1));
16559 if (SWIG_arg_fail(2)) SWIG_fail;
16560 }
16561 }
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16565
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 {
16570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16571 }
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16579 PyObject *resultobj;
16580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16581 int arg2 ;
16582 bool result;
16583 PyObject * obj0 = 0 ;
16584 PyObject * obj1 = 0 ;
16585 char *kwnames[] = {
16586 (char *) "self",(char *) "button", NULL
16587 };
16588
16589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16591 if (SWIG_arg_fail(1)) SWIG_fail;
16592 {
16593 arg2 = (int)(SWIG_As_int(obj1));
16594 if (SWIG_arg_fail(2)) SWIG_fail;
16595 }
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16599
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 {
16604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16605 }
16606 return resultobj;
16607 fail:
16608 return NULL;
16609 }
16610
16611
16612 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16613 PyObject *resultobj;
16614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16615 int arg2 ;
16616 bool result;
16617 PyObject * obj0 = 0 ;
16618 PyObject * obj1 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "self",(char *) "but", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16625 if (SWIG_arg_fail(1)) SWIG_fail;
16626 {
16627 arg2 = (int)(SWIG_As_int(obj1));
16628 if (SWIG_arg_fail(2)) SWIG_fail;
16629 }
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16633
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 {
16638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16639 }
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16647 PyObject *resultobj;
16648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16649 int result;
16650 PyObject * obj0 = 0 ;
16651 char *kwnames[] = {
16652 (char *) "self", NULL
16653 };
16654
16655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16657 if (SWIG_arg_fail(1)) SWIG_fail;
16658 {
16659 PyThreadState* __tstate = wxPyBeginAllowThreads();
16660 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16661
16662 wxPyEndAllowThreads(__tstate);
16663 if (PyErr_Occurred()) SWIG_fail;
16664 }
16665 {
16666 resultobj = SWIG_From_int((int)(result));
16667 }
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16675 PyObject *resultobj;
16676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16677 bool result;
16678 PyObject * obj0 = 0 ;
16679 char *kwnames[] = {
16680 (char *) "self", NULL
16681 };
16682
16683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16685 if (SWIG_arg_fail(1)) SWIG_fail;
16686 {
16687 PyThreadState* __tstate = wxPyBeginAllowThreads();
16688 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16689
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 {
16694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16695 }
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16703 PyObject *resultobj;
16704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16705 bool result;
16706 PyObject * obj0 = 0 ;
16707 char *kwnames[] = {
16708 (char *) "self", NULL
16709 };
16710
16711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16713 if (SWIG_arg_fail(1)) SWIG_fail;
16714 {
16715 PyThreadState* __tstate = wxPyBeginAllowThreads();
16716 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16717
16718 wxPyEndAllowThreads(__tstate);
16719 if (PyErr_Occurred()) SWIG_fail;
16720 }
16721 {
16722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16723 }
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj;
16732 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16733 bool result;
16734 PyObject * obj0 = 0 ;
16735 char *kwnames[] = {
16736 (char *) "self", NULL
16737 };
16738
16739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16741 if (SWIG_arg_fail(1)) SWIG_fail;
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16745
16746 wxPyEndAllowThreads(__tstate);
16747 if (PyErr_Occurred()) SWIG_fail;
16748 }
16749 {
16750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16751 }
16752 return resultobj;
16753 fail:
16754 return NULL;
16755 }
16756
16757
16758 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16759 PyObject *resultobj;
16760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16761 bool result;
16762 PyObject * obj0 = 0 ;
16763 char *kwnames[] = {
16764 (char *) "self", NULL
16765 };
16766
16767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16769 if (SWIG_arg_fail(1)) SWIG_fail;
16770 {
16771 PyThreadState* __tstate = wxPyBeginAllowThreads();
16772 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16773
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 {
16778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16779 }
16780 return resultobj;
16781 fail:
16782 return NULL;
16783 }
16784
16785
16786 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj;
16788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16789 bool result;
16790 PyObject * obj0 = 0 ;
16791 char *kwnames[] = {
16792 (char *) "self", NULL
16793 };
16794
16795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16797 if (SWIG_arg_fail(1)) SWIG_fail;
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16801
16802 wxPyEndAllowThreads(__tstate);
16803 if (PyErr_Occurred()) SWIG_fail;
16804 }
16805 {
16806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16807 }
16808 return resultobj;
16809 fail:
16810 return NULL;
16811 }
16812
16813
16814 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16815 PyObject *resultobj;
16816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16817 bool result;
16818 PyObject * obj0 = 0 ;
16819 char *kwnames[] = {
16820 (char *) "self", NULL
16821 };
16822
16823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16825 if (SWIG_arg_fail(1)) SWIG_fail;
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16829
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 {
16834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16835 }
16836 return resultobj;
16837 fail:
16838 return NULL;
16839 }
16840
16841
16842 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16843 PyObject *resultobj;
16844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16845 bool result;
16846 PyObject * obj0 = 0 ;
16847 char *kwnames[] = {
16848 (char *) "self", NULL
16849 };
16850
16851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16853 if (SWIG_arg_fail(1)) SWIG_fail;
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16857
16858 wxPyEndAllowThreads(__tstate);
16859 if (PyErr_Occurred()) SWIG_fail;
16860 }
16861 {
16862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16863 }
16864 return resultobj;
16865 fail:
16866 return NULL;
16867 }
16868
16869
16870 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16871 PyObject *resultobj;
16872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16873 bool result;
16874 PyObject * obj0 = 0 ;
16875 char *kwnames[] = {
16876 (char *) "self", NULL
16877 };
16878
16879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16881 if (SWIG_arg_fail(1)) SWIG_fail;
16882 {
16883 PyThreadState* __tstate = wxPyBeginAllowThreads();
16884 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16885
16886 wxPyEndAllowThreads(__tstate);
16887 if (PyErr_Occurred()) SWIG_fail;
16888 }
16889 {
16890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16891 }
16892 return resultobj;
16893 fail:
16894 return NULL;
16895 }
16896
16897
16898 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16899 PyObject *resultobj;
16900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16901 bool result;
16902 PyObject * obj0 = 0 ;
16903 char *kwnames[] = {
16904 (char *) "self", NULL
16905 };
16906
16907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16909 if (SWIG_arg_fail(1)) SWIG_fail;
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16913
16914 wxPyEndAllowThreads(__tstate);
16915 if (PyErr_Occurred()) SWIG_fail;
16916 }
16917 {
16918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16919 }
16920 return resultobj;
16921 fail:
16922 return NULL;
16923 }
16924
16925
16926 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16927 PyObject *resultobj;
16928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16929 bool result;
16930 PyObject * obj0 = 0 ;
16931 char *kwnames[] = {
16932 (char *) "self", NULL
16933 };
16934
16935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16937 if (SWIG_arg_fail(1)) SWIG_fail;
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16941
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 {
16946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16947 }
16948 return resultobj;
16949 fail:
16950 return NULL;
16951 }
16952
16953
16954 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16955 PyObject *resultobj;
16956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16957 bool result;
16958 PyObject * obj0 = 0 ;
16959 char *kwnames[] = {
16960 (char *) "self", NULL
16961 };
16962
16963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16965 if (SWIG_arg_fail(1)) SWIG_fail;
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 {
16974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16975 }
16976 return resultobj;
16977 fail:
16978 return NULL;
16979 }
16980
16981
16982 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16983 PyObject *resultobj;
16984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16985 bool result;
16986 PyObject * obj0 = 0 ;
16987 char *kwnames[] = {
16988 (char *) "self", NULL
16989 };
16990
16991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16993 if (SWIG_arg_fail(1)) SWIG_fail;
16994 {
16995 PyThreadState* __tstate = wxPyBeginAllowThreads();
16996 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16997
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 {
17002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17003 }
17004 return resultobj;
17005 fail:
17006 return NULL;
17007 }
17008
17009
17010 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17011 PyObject *resultobj;
17012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17013 bool result;
17014 PyObject * obj0 = 0 ;
17015 char *kwnames[] = {
17016 (char *) "self", NULL
17017 };
17018
17019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17021 if (SWIG_arg_fail(1)) SWIG_fail;
17022 {
17023 PyThreadState* __tstate = wxPyBeginAllowThreads();
17024 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17025
17026 wxPyEndAllowThreads(__tstate);
17027 if (PyErr_Occurred()) SWIG_fail;
17028 }
17029 {
17030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17031 }
17032 return resultobj;
17033 fail:
17034 return NULL;
17035 }
17036
17037
17038 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17039 PyObject *resultobj;
17040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17041 bool result;
17042 PyObject * obj0 = 0 ;
17043 char *kwnames[] = {
17044 (char *) "self", NULL
17045 };
17046
17047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17049 if (SWIG_arg_fail(1)) SWIG_fail;
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17053
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 {
17058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17059 }
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj;
17068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17069 bool result;
17070 PyObject * obj0 = 0 ;
17071 char *kwnames[] = {
17072 (char *) "self", NULL
17073 };
17074
17075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17077 if (SWIG_arg_fail(1)) SWIG_fail;
17078 {
17079 PyThreadState* __tstate = wxPyBeginAllowThreads();
17080 result = (bool)(arg1)->LeftIsDown();
17081
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 return resultobj;
17089 fail:
17090 return NULL;
17091 }
17092
17093
17094 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj;
17096 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17097 bool result;
17098 PyObject * obj0 = 0 ;
17099 char *kwnames[] = {
17100 (char *) "self", NULL
17101 };
17102
17103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17105 if (SWIG_arg_fail(1)) SWIG_fail;
17106 {
17107 PyThreadState* __tstate = wxPyBeginAllowThreads();
17108 result = (bool)(arg1)->MiddleIsDown();
17109
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 {
17114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17115 }
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj;
17124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17125 bool result;
17126 PyObject * obj0 = 0 ;
17127 char *kwnames[] = {
17128 (char *) "self", NULL
17129 };
17130
17131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17133 if (SWIG_arg_fail(1)) SWIG_fail;
17134 {
17135 PyThreadState* __tstate = wxPyBeginAllowThreads();
17136 result = (bool)(arg1)->RightIsDown();
17137
17138 wxPyEndAllowThreads(__tstate);
17139 if (PyErr_Occurred()) SWIG_fail;
17140 }
17141 {
17142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17143 }
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj;
17152 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17153 bool result;
17154 PyObject * obj0 = 0 ;
17155 char *kwnames[] = {
17156 (char *) "self", NULL
17157 };
17158
17159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17161 if (SWIG_arg_fail(1)) SWIG_fail;
17162 {
17163 PyThreadState* __tstate = wxPyBeginAllowThreads();
17164 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17165
17166 wxPyEndAllowThreads(__tstate);
17167 if (PyErr_Occurred()) SWIG_fail;
17168 }
17169 {
17170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17171 }
17172 return resultobj;
17173 fail:
17174 return NULL;
17175 }
17176
17177
17178 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj;
17180 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17181 bool result;
17182 PyObject * obj0 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 {
17191 PyThreadState* __tstate = wxPyBeginAllowThreads();
17192 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17193
17194 wxPyEndAllowThreads(__tstate);
17195 if (PyErr_Occurred()) SWIG_fail;
17196 }
17197 {
17198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17199 }
17200 return resultobj;
17201 fail:
17202 return NULL;
17203 }
17204
17205
17206 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17207 PyObject *resultobj;
17208 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17209 bool result;
17210 PyObject * obj0 = 0 ;
17211 char *kwnames[] = {
17212 (char *) "self", NULL
17213 };
17214
17215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17217 if (SWIG_arg_fail(1)) SWIG_fail;
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17221
17222 wxPyEndAllowThreads(__tstate);
17223 if (PyErr_Occurred()) SWIG_fail;
17224 }
17225 {
17226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17227 }
17228 return resultobj;
17229 fail:
17230 return NULL;
17231 }
17232
17233
17234 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17235 PyObject *resultobj;
17236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17237 bool result;
17238 PyObject * obj0 = 0 ;
17239 char *kwnames[] = {
17240 (char *) "self", NULL
17241 };
17242
17243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17245 if (SWIG_arg_fail(1)) SWIG_fail;
17246 {
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17249
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 {
17254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17255 }
17256 return resultobj;
17257 fail:
17258 return NULL;
17259 }
17260
17261
17262 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17263 PyObject *resultobj;
17264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17265 wxPoint result;
17266 PyObject * obj0 = 0 ;
17267 char *kwnames[] = {
17268 (char *) "self", NULL
17269 };
17270
17271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17273 if (SWIG_arg_fail(1)) SWIG_fail;
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 result = (arg1)->GetPosition();
17277
17278 wxPyEndAllowThreads(__tstate);
17279 if (PyErr_Occurred()) SWIG_fail;
17280 }
17281 {
17282 wxPoint * resultptr;
17283 resultptr = new wxPoint((wxPoint &)(result));
17284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17285 }
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj;
17294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17295 long *arg2 = (long *) 0 ;
17296 long *arg3 = (long *) 0 ;
17297 long temp2 ;
17298 int res2 = 0 ;
17299 long temp3 ;
17300 int res3 = 0 ;
17301 PyObject * obj0 = 0 ;
17302 char *kwnames[] = {
17303 (char *) "self", NULL
17304 };
17305
17306 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17307 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17310 if (SWIG_arg_fail(1)) SWIG_fail;
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 (arg1)->GetPosition(arg2,arg3);
17314
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 Py_INCREF(Py_None); resultobj = Py_None;
17319 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17320 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17321 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17322 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17323 return resultobj;
17324 fail:
17325 return NULL;
17326 }
17327
17328
17329 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17330 PyObject *resultobj;
17331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17332 wxDC *arg2 = 0 ;
17333 wxPoint result;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self",(char *) "dc", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 {
17344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17345 if (SWIG_arg_fail(2)) SWIG_fail;
17346 if (arg2 == NULL) {
17347 SWIG_null_ref("wxDC");
17348 }
17349 if (SWIG_arg_fail(2)) SWIG_fail;
17350 }
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17354
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 {
17359 wxPoint * resultptr;
17360 resultptr = new wxPoint((wxPoint &)(result));
17361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17362 }
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17370 PyObject *resultobj;
17371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17372 int result;
17373 PyObject * obj0 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 result = (int)((wxMouseEvent const *)arg1)->GetX();
17384
17385 wxPyEndAllowThreads(__tstate);
17386 if (PyErr_Occurred()) SWIG_fail;
17387 }
17388 {
17389 resultobj = SWIG_From_int((int)(result));
17390 }
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17398 PyObject *resultobj;
17399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17400 int result;
17401 PyObject * obj0 = 0 ;
17402 char *kwnames[] = {
17403 (char *) "self", NULL
17404 };
17405
17406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17408 if (SWIG_arg_fail(1)) SWIG_fail;
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (int)((wxMouseEvent const *)arg1)->GetY();
17412
17413 wxPyEndAllowThreads(__tstate);
17414 if (PyErr_Occurred()) SWIG_fail;
17415 }
17416 {
17417 resultobj = SWIG_From_int((int)(result));
17418 }
17419 return resultobj;
17420 fail:
17421 return NULL;
17422 }
17423
17424
17425 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17426 PyObject *resultobj;
17427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17428 int result;
17429 PyObject * obj0 = 0 ;
17430 char *kwnames[] = {
17431 (char *) "self", NULL
17432 };
17433
17434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17436 if (SWIG_arg_fail(1)) SWIG_fail;
17437 {
17438 PyThreadState* __tstate = wxPyBeginAllowThreads();
17439 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17440
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 {
17445 resultobj = SWIG_From_int((int)(result));
17446 }
17447 return resultobj;
17448 fail:
17449 return NULL;
17450 }
17451
17452
17453 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17454 PyObject *resultobj;
17455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17456 int result;
17457 PyObject * obj0 = 0 ;
17458 char *kwnames[] = {
17459 (char *) "self", NULL
17460 };
17461
17462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17464 if (SWIG_arg_fail(1)) SWIG_fail;
17465 {
17466 PyThreadState* __tstate = wxPyBeginAllowThreads();
17467 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17468
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 {
17473 resultobj = SWIG_From_int((int)(result));
17474 }
17475 return resultobj;
17476 fail:
17477 return NULL;
17478 }
17479
17480
17481 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj;
17483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17484 int result;
17485 PyObject * obj0 = 0 ;
17486 char *kwnames[] = {
17487 (char *) "self", NULL
17488 };
17489
17490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17492 if (SWIG_arg_fail(1)) SWIG_fail;
17493 {
17494 PyThreadState* __tstate = wxPyBeginAllowThreads();
17495 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17496
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 {
17501 resultobj = SWIG_From_int((int)(result));
17502 }
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17510 PyObject *resultobj;
17511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17512 bool result;
17513 PyObject * obj0 = 0 ;
17514 char *kwnames[] = {
17515 (char *) "self", NULL
17516 };
17517
17518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17520 if (SWIG_arg_fail(1)) SWIG_fail;
17521 {
17522 PyThreadState* __tstate = wxPyBeginAllowThreads();
17523 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17524
17525 wxPyEndAllowThreads(__tstate);
17526 if (PyErr_Occurred()) SWIG_fail;
17527 }
17528 {
17529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17530 }
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj;
17539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17540 int arg2 ;
17541 PyObject * obj0 = 0 ;
17542 PyObject * obj1 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self",(char *) "m_x", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 {
17551 arg2 = (int)(SWIG_As_int(obj1));
17552 if (SWIG_arg_fail(2)) SWIG_fail;
17553 }
17554 if (arg1) (arg1)->m_x = arg2;
17555
17556 Py_INCREF(Py_None); resultobj = Py_None;
17557 return resultobj;
17558 fail:
17559 return NULL;
17560 }
17561
17562
17563 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17564 PyObject *resultobj;
17565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17566 int result;
17567 PyObject * obj0 = 0 ;
17568 char *kwnames[] = {
17569 (char *) "self", NULL
17570 };
17571
17572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17574 if (SWIG_arg_fail(1)) SWIG_fail;
17575 result = (int) ((arg1)->m_x);
17576
17577 {
17578 resultobj = SWIG_From_int((int)(result));
17579 }
17580 return resultobj;
17581 fail:
17582 return NULL;
17583 }
17584
17585
17586 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj;
17588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17589 int arg2 ;
17590 PyObject * obj0 = 0 ;
17591 PyObject * obj1 = 0 ;
17592 char *kwnames[] = {
17593 (char *) "self",(char *) "m_y", NULL
17594 };
17595
17596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17598 if (SWIG_arg_fail(1)) SWIG_fail;
17599 {
17600 arg2 = (int)(SWIG_As_int(obj1));
17601 if (SWIG_arg_fail(2)) SWIG_fail;
17602 }
17603 if (arg1) (arg1)->m_y = arg2;
17604
17605 Py_INCREF(Py_None); resultobj = Py_None;
17606 return resultobj;
17607 fail:
17608 return NULL;
17609 }
17610
17611
17612 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj;
17614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17615 int result;
17616 PyObject * obj0 = 0 ;
17617 char *kwnames[] = {
17618 (char *) "self", NULL
17619 };
17620
17621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17623 if (SWIG_arg_fail(1)) SWIG_fail;
17624 result = (int) ((arg1)->m_y);
17625
17626 {
17627 resultobj = SWIG_From_int((int)(result));
17628 }
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17636 PyObject *resultobj;
17637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17638 bool arg2 ;
17639 PyObject * obj0 = 0 ;
17640 PyObject * obj1 = 0 ;
17641 char *kwnames[] = {
17642 (char *) "self",(char *) "m_leftDown", NULL
17643 };
17644
17645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17647 if (SWIG_arg_fail(1)) SWIG_fail;
17648 {
17649 arg2 = (bool)(SWIG_As_bool(obj1));
17650 if (SWIG_arg_fail(2)) SWIG_fail;
17651 }
17652 if (arg1) (arg1)->m_leftDown = arg2;
17653
17654 Py_INCREF(Py_None); resultobj = Py_None;
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj;
17663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17664 bool result;
17665 PyObject * obj0 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "self", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 result = (bool) ((arg1)->m_leftDown);
17674
17675 {
17676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17677 }
17678 return resultobj;
17679 fail:
17680 return NULL;
17681 }
17682
17683
17684 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17685 PyObject *resultobj;
17686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17687 bool arg2 ;
17688 PyObject * obj0 = 0 ;
17689 PyObject * obj1 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self",(char *) "m_middleDown", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 arg2 = (bool)(SWIG_As_bool(obj1));
17699 if (SWIG_arg_fail(2)) SWIG_fail;
17700 }
17701 if (arg1) (arg1)->m_middleDown = arg2;
17702
17703 Py_INCREF(Py_None); resultobj = Py_None;
17704 return resultobj;
17705 fail:
17706 return NULL;
17707 }
17708
17709
17710 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17711 PyObject *resultobj;
17712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17713 bool result;
17714 PyObject * obj0 = 0 ;
17715 char *kwnames[] = {
17716 (char *) "self", NULL
17717 };
17718
17719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17721 if (SWIG_arg_fail(1)) SWIG_fail;
17722 result = (bool) ((arg1)->m_middleDown);
17723
17724 {
17725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17726 }
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj;
17735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17736 bool arg2 ;
17737 PyObject * obj0 = 0 ;
17738 PyObject * obj1 = 0 ;
17739 char *kwnames[] = {
17740 (char *) "self",(char *) "m_rightDown", NULL
17741 };
17742
17743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17745 if (SWIG_arg_fail(1)) SWIG_fail;
17746 {
17747 arg2 = (bool)(SWIG_As_bool(obj1));
17748 if (SWIG_arg_fail(2)) SWIG_fail;
17749 }
17750 if (arg1) (arg1)->m_rightDown = arg2;
17751
17752 Py_INCREF(Py_None); resultobj = Py_None;
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj;
17761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17762 bool result;
17763 PyObject * obj0 = 0 ;
17764 char *kwnames[] = {
17765 (char *) "self", NULL
17766 };
17767
17768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17770 if (SWIG_arg_fail(1)) SWIG_fail;
17771 result = (bool) ((arg1)->m_rightDown);
17772
17773 {
17774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17775 }
17776 return resultobj;
17777 fail:
17778 return NULL;
17779 }
17780
17781
17782 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17783 PyObject *resultobj;
17784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17785 bool arg2 ;
17786 PyObject * obj0 = 0 ;
17787 PyObject * obj1 = 0 ;
17788 char *kwnames[] = {
17789 (char *) "self",(char *) "m_controlDown", NULL
17790 };
17791
17792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17794 if (SWIG_arg_fail(1)) SWIG_fail;
17795 {
17796 arg2 = (bool)(SWIG_As_bool(obj1));
17797 if (SWIG_arg_fail(2)) SWIG_fail;
17798 }
17799 if (arg1) (arg1)->m_controlDown = arg2;
17800
17801 Py_INCREF(Py_None); resultobj = Py_None;
17802 return resultobj;
17803 fail:
17804 return NULL;
17805 }
17806
17807
17808 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17809 PyObject *resultobj;
17810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17811 bool result;
17812 PyObject * obj0 = 0 ;
17813 char *kwnames[] = {
17814 (char *) "self", NULL
17815 };
17816
17817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17819 if (SWIG_arg_fail(1)) SWIG_fail;
17820 result = (bool) ((arg1)->m_controlDown);
17821
17822 {
17823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17824 }
17825 return resultobj;
17826 fail:
17827 return NULL;
17828 }
17829
17830
17831 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17832 PyObject *resultobj;
17833 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17834 bool arg2 ;
17835 PyObject * obj0 = 0 ;
17836 PyObject * obj1 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self",(char *) "m_shiftDown", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(1)) SWIG_fail;
17844 {
17845 arg2 = (bool)(SWIG_As_bool(obj1));
17846 if (SWIG_arg_fail(2)) SWIG_fail;
17847 }
17848 if (arg1) (arg1)->m_shiftDown = arg2;
17849
17850 Py_INCREF(Py_None); resultobj = Py_None;
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj;
17859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17860 bool result;
17861 PyObject * obj0 = 0 ;
17862 char *kwnames[] = {
17863 (char *) "self", NULL
17864 };
17865
17866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17868 if (SWIG_arg_fail(1)) SWIG_fail;
17869 result = (bool) ((arg1)->m_shiftDown);
17870
17871 {
17872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17873 }
17874 return resultobj;
17875 fail:
17876 return NULL;
17877 }
17878
17879
17880 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17881 PyObject *resultobj;
17882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17883 bool arg2 ;
17884 PyObject * obj0 = 0 ;
17885 PyObject * obj1 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "self",(char *) "m_altDown", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17892 if (SWIG_arg_fail(1)) SWIG_fail;
17893 {
17894 arg2 = (bool)(SWIG_As_bool(obj1));
17895 if (SWIG_arg_fail(2)) SWIG_fail;
17896 }
17897 if (arg1) (arg1)->m_altDown = arg2;
17898
17899 Py_INCREF(Py_None); resultobj = Py_None;
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj;
17908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17909 bool result;
17910 PyObject * obj0 = 0 ;
17911 char *kwnames[] = {
17912 (char *) "self", NULL
17913 };
17914
17915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17917 if (SWIG_arg_fail(1)) SWIG_fail;
17918 result = (bool) ((arg1)->m_altDown);
17919
17920 {
17921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17922 }
17923 return resultobj;
17924 fail:
17925 return NULL;
17926 }
17927
17928
17929 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17930 PyObject *resultobj;
17931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17932 bool arg2 ;
17933 PyObject * obj0 = 0 ;
17934 PyObject * obj1 = 0 ;
17935 char *kwnames[] = {
17936 (char *) "self",(char *) "m_metaDown", NULL
17937 };
17938
17939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17941 if (SWIG_arg_fail(1)) SWIG_fail;
17942 {
17943 arg2 = (bool)(SWIG_As_bool(obj1));
17944 if (SWIG_arg_fail(2)) SWIG_fail;
17945 }
17946 if (arg1) (arg1)->m_metaDown = arg2;
17947
17948 Py_INCREF(Py_None); resultobj = Py_None;
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj;
17957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17958 bool result;
17959 PyObject * obj0 = 0 ;
17960 char *kwnames[] = {
17961 (char *) "self", NULL
17962 };
17963
17964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 result = (bool) ((arg1)->m_metaDown);
17968
17969 {
17970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17971 }
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj;
17980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17981 int arg2 ;
17982 PyObject * obj0 = 0 ;
17983 PyObject * obj1 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self",(char *) "m_wheelRotation", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 {
17992 arg2 = (int)(SWIG_As_int(obj1));
17993 if (SWIG_arg_fail(2)) SWIG_fail;
17994 }
17995 if (arg1) (arg1)->m_wheelRotation = arg2;
17996
17997 Py_INCREF(Py_None); resultobj = Py_None;
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj;
18006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18007 int result;
18008 PyObject * obj0 = 0 ;
18009 char *kwnames[] = {
18010 (char *) "self", NULL
18011 };
18012
18013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18015 if (SWIG_arg_fail(1)) SWIG_fail;
18016 result = (int) ((arg1)->m_wheelRotation);
18017
18018 {
18019 resultobj = SWIG_From_int((int)(result));
18020 }
18021 return resultobj;
18022 fail:
18023 return NULL;
18024 }
18025
18026
18027 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18028 PyObject *resultobj;
18029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18030 int arg2 ;
18031 PyObject * obj0 = 0 ;
18032 PyObject * obj1 = 0 ;
18033 char *kwnames[] = {
18034 (char *) "self",(char *) "m_wheelDelta", NULL
18035 };
18036
18037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18039 if (SWIG_arg_fail(1)) SWIG_fail;
18040 {
18041 arg2 = (int)(SWIG_As_int(obj1));
18042 if (SWIG_arg_fail(2)) SWIG_fail;
18043 }
18044 if (arg1) (arg1)->m_wheelDelta = arg2;
18045
18046 Py_INCREF(Py_None); resultobj = Py_None;
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj;
18055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18056 int result;
18057 PyObject * obj0 = 0 ;
18058 char *kwnames[] = {
18059 (char *) "self", NULL
18060 };
18061
18062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18064 if (SWIG_arg_fail(1)) SWIG_fail;
18065 result = (int) ((arg1)->m_wheelDelta);
18066
18067 {
18068 resultobj = SWIG_From_int((int)(result));
18069 }
18070 return resultobj;
18071 fail:
18072 return NULL;
18073 }
18074
18075
18076 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18077 PyObject *resultobj;
18078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18079 int arg2 ;
18080 PyObject * obj0 = 0 ;
18081 PyObject * obj1 = 0 ;
18082 char *kwnames[] = {
18083 (char *) "self",(char *) "m_linesPerAction", NULL
18084 };
18085
18086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18088 if (SWIG_arg_fail(1)) SWIG_fail;
18089 {
18090 arg2 = (int)(SWIG_As_int(obj1));
18091 if (SWIG_arg_fail(2)) SWIG_fail;
18092 }
18093 if (arg1) (arg1)->m_linesPerAction = arg2;
18094
18095 Py_INCREF(Py_None); resultobj = Py_None;
18096 return resultobj;
18097 fail:
18098 return NULL;
18099 }
18100
18101
18102 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj;
18104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18105 int result;
18106 PyObject * obj0 = 0 ;
18107 char *kwnames[] = {
18108 (char *) "self", NULL
18109 };
18110
18111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18113 if (SWIG_arg_fail(1)) SWIG_fail;
18114 result = (int) ((arg1)->m_linesPerAction);
18115
18116 {
18117 resultobj = SWIG_From_int((int)(result));
18118 }
18119 return resultobj;
18120 fail:
18121 return NULL;
18122 }
18123
18124
18125 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18126 PyObject *obj;
18127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18128 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18129 Py_INCREF(obj);
18130 return Py_BuildValue((char *)"");
18131 }
18132 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18133 PyObject *resultobj;
18134 int arg1 = (int) 0 ;
18135 int arg2 = (int) 0 ;
18136 wxSetCursorEvent *result;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char *kwnames[] = {
18140 (char *) "x",(char *) "y", NULL
18141 };
18142
18143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18144 if (obj0) {
18145 {
18146 arg1 = (int)(SWIG_As_int(obj0));
18147 if (SWIG_arg_fail(1)) SWIG_fail;
18148 }
18149 }
18150 if (obj1) {
18151 {
18152 arg2 = (int)(SWIG_As_int(obj1));
18153 if (SWIG_arg_fail(2)) SWIG_fail;
18154 }
18155 }
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18159
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18171 PyObject *resultobj;
18172 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18173 int result;
18174 PyObject * obj0 = 0 ;
18175 char *kwnames[] = {
18176 (char *) "self", NULL
18177 };
18178
18179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18181 if (SWIG_arg_fail(1)) SWIG_fail;
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18185
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 {
18190 resultobj = SWIG_From_int((int)(result));
18191 }
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18199 PyObject *resultobj;
18200 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18201 int result;
18202 PyObject * obj0 = 0 ;
18203 char *kwnames[] = {
18204 (char *) "self", NULL
18205 };
18206
18207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18209 if (SWIG_arg_fail(1)) SWIG_fail;
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18213
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 {
18218 resultobj = SWIG_From_int((int)(result));
18219 }
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj;
18228 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18229 wxCursor *arg2 = 0 ;
18230 PyObject * obj0 = 0 ;
18231 PyObject * obj1 = 0 ;
18232 char *kwnames[] = {
18233 (char *) "self",(char *) "cursor", NULL
18234 };
18235
18236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18238 if (SWIG_arg_fail(1)) SWIG_fail;
18239 {
18240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18241 if (SWIG_arg_fail(2)) SWIG_fail;
18242 if (arg2 == NULL) {
18243 SWIG_null_ref("wxCursor");
18244 }
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 }
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 (arg1)->SetCursor((wxCursor const &)*arg2);
18250
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 Py_INCREF(Py_None); resultobj = Py_None;
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj;
18263 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18264 wxCursor *result;
18265 PyObject * obj0 = 0 ;
18266 char *kwnames[] = {
18267 (char *) "self", NULL
18268 };
18269
18270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18272 if (SWIG_arg_fail(1)) SWIG_fail;
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 {
18276 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18277 result = (wxCursor *) &_result_ref;
18278 }
18279
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 {
18284 wxCursor* resultptr = new wxCursor(*result);
18285 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18286 }
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj;
18295 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18296 bool result;
18297 PyObject * obj0 = 0 ;
18298 char *kwnames[] = {
18299 (char *) "self", NULL
18300 };
18301
18302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18304 if (SWIG_arg_fail(1)) SWIG_fail;
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18308
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 {
18313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18314 }
18315 return resultobj;
18316 fail:
18317 return NULL;
18318 }
18319
18320
18321 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18322 PyObject *obj;
18323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18324 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18325 Py_INCREF(obj);
18326 return Py_BuildValue((char *)"");
18327 }
18328 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18329 PyObject *resultobj;
18330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18331 wxKeyEvent *result;
18332 PyObject * obj0 = 0 ;
18333 char *kwnames[] = {
18334 (char *) "keyType", NULL
18335 };
18336
18337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18338 if (obj0) {
18339 {
18340 arg1 = (wxEventType)(SWIG_As_int(obj0));
18341 if (SWIG_arg_fail(1)) SWIG_fail;
18342 }
18343 }
18344 {
18345 PyThreadState* __tstate = wxPyBeginAllowThreads();
18346 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18347
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj;
18360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18361 bool result;
18362 PyObject * obj0 = 0 ;
18363 char *kwnames[] = {
18364 (char *) "self", NULL
18365 };
18366
18367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18369 if (SWIG_arg_fail(1)) SWIG_fail;
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 {
18378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18379 }
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj;
18388 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18389 bool result;
18390 PyObject * obj0 = 0 ;
18391 char *kwnames[] = {
18392 (char *) "self", NULL
18393 };
18394
18395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18397 if (SWIG_arg_fail(1)) SWIG_fail;
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18401
18402 wxPyEndAllowThreads(__tstate);
18403 if (PyErr_Occurred()) SWIG_fail;
18404 }
18405 {
18406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18407 }
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj;
18416 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18417 bool result;
18418 PyObject * obj0 = 0 ;
18419 char *kwnames[] = {
18420 (char *) "self", NULL
18421 };
18422
18423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18425 if (SWIG_arg_fail(1)) SWIG_fail;
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18429
18430 wxPyEndAllowThreads(__tstate);
18431 if (PyErr_Occurred()) SWIG_fail;
18432 }
18433 {
18434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18435 }
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj;
18444 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18445 bool result;
18446 PyObject * obj0 = 0 ;
18447 char *kwnames[] = {
18448 (char *) "self", NULL
18449 };
18450
18451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18453 if (SWIG_arg_fail(1)) SWIG_fail;
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18457
18458 wxPyEndAllowThreads(__tstate);
18459 if (PyErr_Occurred()) SWIG_fail;
18460 }
18461 {
18462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18463 }
18464 return resultobj;
18465 fail:
18466 return NULL;
18467 }
18468
18469
18470 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18471 PyObject *resultobj;
18472 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18473 bool result;
18474 PyObject * obj0 = 0 ;
18475 char *kwnames[] = {
18476 (char *) "self", NULL
18477 };
18478
18479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18481 if (SWIG_arg_fail(1)) SWIG_fail;
18482 {
18483 PyThreadState* __tstate = wxPyBeginAllowThreads();
18484 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18485
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 {
18490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18491 }
18492 return resultobj;
18493 fail:
18494 return NULL;
18495 }
18496
18497
18498 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18499 PyObject *resultobj;
18500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18501 bool result;
18502 PyObject * obj0 = 0 ;
18503 char *kwnames[] = {
18504 (char *) "self", NULL
18505 };
18506
18507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18509 if (SWIG_arg_fail(1)) SWIG_fail;
18510 {
18511 PyThreadState* __tstate = wxPyBeginAllowThreads();
18512 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18513
18514 wxPyEndAllowThreads(__tstate);
18515 if (PyErr_Occurred()) SWIG_fail;
18516 }
18517 {
18518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18519 }
18520 return resultobj;
18521 fail:
18522 return NULL;
18523 }
18524
18525
18526 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18527 PyObject *resultobj;
18528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18529 int result;
18530 PyObject * obj0 = 0 ;
18531 char *kwnames[] = {
18532 (char *) "self", NULL
18533 };
18534
18535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18537 if (SWIG_arg_fail(1)) SWIG_fail;
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18541
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 {
18546 resultobj = SWIG_From_int((int)(result));
18547 }
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18555 PyObject *resultobj;
18556 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18557 int result;
18558 PyObject * obj0 = 0 ;
18559 char *kwnames[] = {
18560 (char *) "self", NULL
18561 };
18562
18563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18565 if (SWIG_arg_fail(1)) SWIG_fail;
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18569
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 {
18574 resultobj = SWIG_From_int((int)(result));
18575 }
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18583 PyObject *resultobj;
18584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18585 unsigned int result;
18586 PyObject * obj0 = 0 ;
18587 char *kwnames[] = {
18588 (char *) "self", NULL
18589 };
18590
18591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18593 if (SWIG_arg_fail(1)) SWIG_fail;
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18597
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 {
18602 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18603 }
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18611 PyObject *resultobj;
18612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18613 unsigned int result;
18614 PyObject * obj0 = 0 ;
18615 char *kwnames[] = {
18616 (char *) "self", NULL
18617 };
18618
18619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18621 if (SWIG_arg_fail(1)) SWIG_fail;
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18625
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 {
18630 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18631 }
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18639 PyObject *resultobj;
18640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18641 wxPoint result;
18642 PyObject * obj0 = 0 ;
18643 char *kwnames[] = {
18644 (char *) "self", NULL
18645 };
18646
18647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18649 if (SWIG_arg_fail(1)) SWIG_fail;
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = (arg1)->GetPosition();
18653
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 {
18658 wxPoint * resultptr;
18659 resultptr = new wxPoint((wxPoint &)(result));
18660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18661 }
18662 return resultobj;
18663 fail:
18664 return NULL;
18665 }
18666
18667
18668 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18669 PyObject *resultobj;
18670 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18671 long *arg2 = (long *) 0 ;
18672 long *arg3 = (long *) 0 ;
18673 long temp2 ;
18674 int res2 = 0 ;
18675 long temp3 ;
18676 int res3 = 0 ;
18677 PyObject * obj0 = 0 ;
18678 char *kwnames[] = {
18679 (char *) "self", NULL
18680 };
18681
18682 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18683 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18686 if (SWIG_arg_fail(1)) SWIG_fail;
18687 {
18688 PyThreadState* __tstate = wxPyBeginAllowThreads();
18689 (arg1)->GetPosition(arg2,arg3);
18690
18691 wxPyEndAllowThreads(__tstate);
18692 if (PyErr_Occurred()) SWIG_fail;
18693 }
18694 Py_INCREF(Py_None); resultobj = Py_None;
18695 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18696 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18697 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18698 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18699 return resultobj;
18700 fail:
18701 return NULL;
18702 }
18703
18704
18705 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18706 PyObject *resultobj;
18707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18708 int result;
18709 PyObject * obj0 = 0 ;
18710 char *kwnames[] = {
18711 (char *) "self", NULL
18712 };
18713
18714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18716 if (SWIG_arg_fail(1)) SWIG_fail;
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 result = (int)((wxKeyEvent const *)arg1)->GetX();
18720
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 {
18725 resultobj = SWIG_From_int((int)(result));
18726 }
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18734 PyObject *resultobj;
18735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18736 int result;
18737 PyObject * obj0 = 0 ;
18738 char *kwnames[] = {
18739 (char *) "self", NULL
18740 };
18741
18742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18744 if (SWIG_arg_fail(1)) SWIG_fail;
18745 {
18746 PyThreadState* __tstate = wxPyBeginAllowThreads();
18747 result = (int)((wxKeyEvent const *)arg1)->GetY();
18748
18749 wxPyEndAllowThreads(__tstate);
18750 if (PyErr_Occurred()) SWIG_fail;
18751 }
18752 {
18753 resultobj = SWIG_From_int((int)(result));
18754 }
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj;
18763 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18764 int arg2 ;
18765 PyObject * obj0 = 0 ;
18766 PyObject * obj1 = 0 ;
18767 char *kwnames[] = {
18768 (char *) "self",(char *) "m_x", NULL
18769 };
18770
18771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18773 if (SWIG_arg_fail(1)) SWIG_fail;
18774 {
18775 arg2 = (int)(SWIG_As_int(obj1));
18776 if (SWIG_arg_fail(2)) SWIG_fail;
18777 }
18778 if (arg1) (arg1)->m_x = arg2;
18779
18780 Py_INCREF(Py_None); resultobj = Py_None;
18781 return resultobj;
18782 fail:
18783 return NULL;
18784 }
18785
18786
18787 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18788 PyObject *resultobj;
18789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18790 int result;
18791 PyObject * obj0 = 0 ;
18792 char *kwnames[] = {
18793 (char *) "self", NULL
18794 };
18795
18796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18798 if (SWIG_arg_fail(1)) SWIG_fail;
18799 result = (int) ((arg1)->m_x);
18800
18801 {
18802 resultobj = SWIG_From_int((int)(result));
18803 }
18804 return resultobj;
18805 fail:
18806 return NULL;
18807 }
18808
18809
18810 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18811 PyObject *resultobj;
18812 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18813 int arg2 ;
18814 PyObject * obj0 = 0 ;
18815 PyObject * obj1 = 0 ;
18816 char *kwnames[] = {
18817 (char *) "self",(char *) "m_y", NULL
18818 };
18819
18820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18822 if (SWIG_arg_fail(1)) SWIG_fail;
18823 {
18824 arg2 = (int)(SWIG_As_int(obj1));
18825 if (SWIG_arg_fail(2)) SWIG_fail;
18826 }
18827 if (arg1) (arg1)->m_y = arg2;
18828
18829 Py_INCREF(Py_None); resultobj = Py_None;
18830 return resultobj;
18831 fail:
18832 return NULL;
18833 }
18834
18835
18836 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18837 PyObject *resultobj;
18838 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18839 int result;
18840 PyObject * obj0 = 0 ;
18841 char *kwnames[] = {
18842 (char *) "self", NULL
18843 };
18844
18845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18847 if (SWIG_arg_fail(1)) SWIG_fail;
18848 result = (int) ((arg1)->m_y);
18849
18850 {
18851 resultobj = SWIG_From_int((int)(result));
18852 }
18853 return resultobj;
18854 fail:
18855 return NULL;
18856 }
18857
18858
18859 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18860 PyObject *resultobj;
18861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18862 long arg2 ;
18863 PyObject * obj0 = 0 ;
18864 PyObject * obj1 = 0 ;
18865 char *kwnames[] = {
18866 (char *) "self",(char *) "m_keyCode", NULL
18867 };
18868
18869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18871 if (SWIG_arg_fail(1)) SWIG_fail;
18872 {
18873 arg2 = (long)(SWIG_As_long(obj1));
18874 if (SWIG_arg_fail(2)) SWIG_fail;
18875 }
18876 if (arg1) (arg1)->m_keyCode = arg2;
18877
18878 Py_INCREF(Py_None); resultobj = Py_None;
18879 return resultobj;
18880 fail:
18881 return NULL;
18882 }
18883
18884
18885 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18886 PyObject *resultobj;
18887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18888 long result;
18889 PyObject * obj0 = 0 ;
18890 char *kwnames[] = {
18891 (char *) "self", NULL
18892 };
18893
18894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18896 if (SWIG_arg_fail(1)) SWIG_fail;
18897 result = (long) ((arg1)->m_keyCode);
18898
18899 {
18900 resultobj = SWIG_From_long((long)(result));
18901 }
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18909 PyObject *resultobj;
18910 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18911 bool arg2 ;
18912 PyObject * obj0 = 0 ;
18913 PyObject * obj1 = 0 ;
18914 char *kwnames[] = {
18915 (char *) "self",(char *) "m_controlDown", NULL
18916 };
18917
18918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18920 if (SWIG_arg_fail(1)) SWIG_fail;
18921 {
18922 arg2 = (bool)(SWIG_As_bool(obj1));
18923 if (SWIG_arg_fail(2)) SWIG_fail;
18924 }
18925 if (arg1) (arg1)->m_controlDown = arg2;
18926
18927 Py_INCREF(Py_None); resultobj = Py_None;
18928 return resultobj;
18929 fail:
18930 return NULL;
18931 }
18932
18933
18934 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18935 PyObject *resultobj;
18936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18937 bool result;
18938 PyObject * obj0 = 0 ;
18939 char *kwnames[] = {
18940 (char *) "self", NULL
18941 };
18942
18943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 result = (bool) ((arg1)->m_controlDown);
18947
18948 {
18949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18950 }
18951 return resultobj;
18952 fail:
18953 return NULL;
18954 }
18955
18956
18957 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18958 PyObject *resultobj;
18959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18960 bool arg2 ;
18961 PyObject * obj0 = 0 ;
18962 PyObject * obj1 = 0 ;
18963 char *kwnames[] = {
18964 (char *) "self",(char *) "m_shiftDown", NULL
18965 };
18966
18967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18969 if (SWIG_arg_fail(1)) SWIG_fail;
18970 {
18971 arg2 = (bool)(SWIG_As_bool(obj1));
18972 if (SWIG_arg_fail(2)) SWIG_fail;
18973 }
18974 if (arg1) (arg1)->m_shiftDown = arg2;
18975
18976 Py_INCREF(Py_None); resultobj = Py_None;
18977 return resultobj;
18978 fail:
18979 return NULL;
18980 }
18981
18982
18983 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18984 PyObject *resultobj;
18985 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18986 bool result;
18987 PyObject * obj0 = 0 ;
18988 char *kwnames[] = {
18989 (char *) "self", NULL
18990 };
18991
18992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18994 if (SWIG_arg_fail(1)) SWIG_fail;
18995 result = (bool) ((arg1)->m_shiftDown);
18996
18997 {
18998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18999 }
19000 return resultobj;
19001 fail:
19002 return NULL;
19003 }
19004
19005
19006 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19007 PyObject *resultobj;
19008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19009 bool arg2 ;
19010 PyObject * obj0 = 0 ;
19011 PyObject * obj1 = 0 ;
19012 char *kwnames[] = {
19013 (char *) "self",(char *) "m_altDown", NULL
19014 };
19015
19016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19018 if (SWIG_arg_fail(1)) SWIG_fail;
19019 {
19020 arg2 = (bool)(SWIG_As_bool(obj1));
19021 if (SWIG_arg_fail(2)) SWIG_fail;
19022 }
19023 if (arg1) (arg1)->m_altDown = arg2;
19024
19025 Py_INCREF(Py_None); resultobj = Py_None;
19026 return resultobj;
19027 fail:
19028 return NULL;
19029 }
19030
19031
19032 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19033 PyObject *resultobj;
19034 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19035 bool result;
19036 PyObject * obj0 = 0 ;
19037 char *kwnames[] = {
19038 (char *) "self", NULL
19039 };
19040
19041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 result = (bool) ((arg1)->m_altDown);
19045
19046 {
19047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19048 }
19049 return resultobj;
19050 fail:
19051 return NULL;
19052 }
19053
19054
19055 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19056 PyObject *resultobj;
19057 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19058 bool arg2 ;
19059 PyObject * obj0 = 0 ;
19060 PyObject * obj1 = 0 ;
19061 char *kwnames[] = {
19062 (char *) "self",(char *) "m_metaDown", NULL
19063 };
19064
19065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19067 if (SWIG_arg_fail(1)) SWIG_fail;
19068 {
19069 arg2 = (bool)(SWIG_As_bool(obj1));
19070 if (SWIG_arg_fail(2)) SWIG_fail;
19071 }
19072 if (arg1) (arg1)->m_metaDown = arg2;
19073
19074 Py_INCREF(Py_None); resultobj = Py_None;
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19082 PyObject *resultobj;
19083 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19084 bool result;
19085 PyObject * obj0 = 0 ;
19086 char *kwnames[] = {
19087 (char *) "self", NULL
19088 };
19089
19090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 result = (bool) ((arg1)->m_metaDown);
19094
19095 {
19096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19097 }
19098 return resultobj;
19099 fail:
19100 return NULL;
19101 }
19102
19103
19104 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19105 PyObject *resultobj;
19106 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19107 bool arg2 ;
19108 PyObject * obj0 = 0 ;
19109 PyObject * obj1 = 0 ;
19110 char *kwnames[] = {
19111 (char *) "self",(char *) "m_scanCode", NULL
19112 };
19113
19114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19116 if (SWIG_arg_fail(1)) SWIG_fail;
19117 {
19118 arg2 = (bool)(SWIG_As_bool(obj1));
19119 if (SWIG_arg_fail(2)) SWIG_fail;
19120 }
19121 if (arg1) (arg1)->m_scanCode = arg2;
19122
19123 Py_INCREF(Py_None); resultobj = Py_None;
19124 return resultobj;
19125 fail:
19126 return NULL;
19127 }
19128
19129
19130 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19131 PyObject *resultobj;
19132 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19133 bool result;
19134 PyObject * obj0 = 0 ;
19135 char *kwnames[] = {
19136 (char *) "self", NULL
19137 };
19138
19139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19141 if (SWIG_arg_fail(1)) SWIG_fail;
19142 result = (bool) ((arg1)->m_scanCode);
19143
19144 {
19145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19146 }
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19154 PyObject *resultobj;
19155 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19156 unsigned int arg2 ;
19157 PyObject * obj0 = 0 ;
19158 PyObject * obj1 = 0 ;
19159 char *kwnames[] = {
19160 (char *) "self",(char *) "m_rawCode", NULL
19161 };
19162
19163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19165 if (SWIG_arg_fail(1)) SWIG_fail;
19166 {
19167 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19168 if (SWIG_arg_fail(2)) SWIG_fail;
19169 }
19170 if (arg1) (arg1)->m_rawCode = arg2;
19171
19172 Py_INCREF(Py_None); resultobj = Py_None;
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19182 unsigned int result;
19183 PyObject * obj0 = 0 ;
19184 char *kwnames[] = {
19185 (char *) "self", NULL
19186 };
19187
19188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19190 if (SWIG_arg_fail(1)) SWIG_fail;
19191 result = (unsigned int) ((arg1)->m_rawCode);
19192
19193 {
19194 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19195 }
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19203 PyObject *resultobj;
19204 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19205 unsigned int arg2 ;
19206 PyObject * obj0 = 0 ;
19207 PyObject * obj1 = 0 ;
19208 char *kwnames[] = {
19209 (char *) "self",(char *) "m_rawFlags", NULL
19210 };
19211
19212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19214 if (SWIG_arg_fail(1)) SWIG_fail;
19215 {
19216 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19217 if (SWIG_arg_fail(2)) SWIG_fail;
19218 }
19219 if (arg1) (arg1)->m_rawFlags = arg2;
19220
19221 Py_INCREF(Py_None); resultobj = Py_None;
19222 return resultobj;
19223 fail:
19224 return NULL;
19225 }
19226
19227
19228 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19229 PyObject *resultobj;
19230 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19231 unsigned int result;
19232 PyObject * obj0 = 0 ;
19233 char *kwnames[] = {
19234 (char *) "self", NULL
19235 };
19236
19237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19239 if (SWIG_arg_fail(1)) SWIG_fail;
19240 result = (unsigned int) ((arg1)->m_rawFlags);
19241
19242 {
19243 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19244 }
19245 return resultobj;
19246 fail:
19247 return NULL;
19248 }
19249
19250
19251 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19252 PyObject *obj;
19253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19254 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19255 Py_INCREF(obj);
19256 return Py_BuildValue((char *)"");
19257 }
19258 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj;
19260 wxSize const &arg1_defvalue = wxDefaultSize ;
19261 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19262 int arg2 = (int) 0 ;
19263 wxSizeEvent *result;
19264 wxSize temp1 ;
19265 PyObject * obj0 = 0 ;
19266 PyObject * obj1 = 0 ;
19267 char *kwnames[] = {
19268 (char *) "sz",(char *) "winid", NULL
19269 };
19270
19271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19272 if (obj0) {
19273 {
19274 arg1 = &temp1;
19275 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19276 }
19277 }
19278 if (obj1) {
19279 {
19280 arg2 = (int)(SWIG_As_int(obj1));
19281 if (SWIG_arg_fail(2)) SWIG_fail;
19282 }
19283 }
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19287
19288 wxPyEndAllowThreads(__tstate);
19289 if (PyErr_Occurred()) SWIG_fail;
19290 }
19291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19299 PyObject *resultobj;
19300 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19301 wxSize result;
19302 PyObject * obj0 = 0 ;
19303 char *kwnames[] = {
19304 (char *) "self", NULL
19305 };
19306
19307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19309 if (SWIG_arg_fail(1)) SWIG_fail;
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = ((wxSizeEvent const *)arg1)->GetSize();
19313
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 {
19318 wxSize * resultptr;
19319 resultptr = new wxSize((wxSize &)(result));
19320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj;
19330 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19331 wxRect result;
19332 PyObject * obj0 = 0 ;
19333 char *kwnames[] = {
19334 (char *) "self", NULL
19335 };
19336
19337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19339 if (SWIG_arg_fail(1)) SWIG_fail;
19340 {
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 result = ((wxSizeEvent const *)arg1)->GetRect();
19343
19344 wxPyEndAllowThreads(__tstate);
19345 if (PyErr_Occurred()) SWIG_fail;
19346 }
19347 {
19348 wxRect * resultptr;
19349 resultptr = new wxRect((wxRect &)(result));
19350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19351 }
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19359 PyObject *resultobj;
19360 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19361 wxRect arg2 ;
19362 PyObject * obj0 = 0 ;
19363 PyObject * obj1 = 0 ;
19364 char *kwnames[] = {
19365 (char *) "self",(char *) "rect", NULL
19366 };
19367
19368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19370 if (SWIG_arg_fail(1)) SWIG_fail;
19371 {
19372 wxRect * argp;
19373 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19374 if (SWIG_arg_fail(2)) SWIG_fail;
19375 if (argp == NULL) {
19376 SWIG_null_ref("wxRect");
19377 }
19378 if (SWIG_arg_fail(2)) SWIG_fail;
19379 arg2 = *argp;
19380 }
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 (arg1)->SetRect(arg2);
19384
19385 wxPyEndAllowThreads(__tstate);
19386 if (PyErr_Occurred()) SWIG_fail;
19387 }
19388 Py_INCREF(Py_None); resultobj = Py_None;
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19396 PyObject *resultobj;
19397 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19398 wxSize arg2 ;
19399 PyObject * obj0 = 0 ;
19400 PyObject * obj1 = 0 ;
19401 char *kwnames[] = {
19402 (char *) "self",(char *) "size", NULL
19403 };
19404
19405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19407 if (SWIG_arg_fail(1)) SWIG_fail;
19408 {
19409 wxSize * argp;
19410 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19411 if (SWIG_arg_fail(2)) SWIG_fail;
19412 if (argp == NULL) {
19413 SWIG_null_ref("wxSize");
19414 }
19415 if (SWIG_arg_fail(2)) SWIG_fail;
19416 arg2 = *argp;
19417 }
19418 {
19419 PyThreadState* __tstate = wxPyBeginAllowThreads();
19420 wxSizeEvent_SetSize(arg1,arg2);
19421
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 Py_INCREF(Py_None); resultobj = Py_None;
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj;
19434 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19435 wxSize *arg2 = (wxSize *) 0 ;
19436 PyObject * obj0 = 0 ;
19437 PyObject * obj1 = 0 ;
19438 char *kwnames[] = {
19439 (char *) "self",(char *) "m_size", NULL
19440 };
19441
19442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19444 if (SWIG_arg_fail(1)) SWIG_fail;
19445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19446 if (SWIG_arg_fail(2)) SWIG_fail;
19447 if (arg1) (arg1)->m_size = *arg2;
19448
19449 Py_INCREF(Py_None); resultobj = Py_None;
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19457 PyObject *resultobj;
19458 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19459 wxSize *result;
19460 PyObject * obj0 = 0 ;
19461 char *kwnames[] = {
19462 (char *) "self", NULL
19463 };
19464
19465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19467 if (SWIG_arg_fail(1)) SWIG_fail;
19468 result = (wxSize *)& ((arg1)->m_size);
19469
19470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19478 PyObject *resultobj;
19479 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19480 wxRect *arg2 = (wxRect *) 0 ;
19481 PyObject * obj0 = 0 ;
19482 PyObject * obj1 = 0 ;
19483 char *kwnames[] = {
19484 (char *) "self",(char *) "m_rect", NULL
19485 };
19486
19487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19489 if (SWIG_arg_fail(1)) SWIG_fail;
19490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19491 if (SWIG_arg_fail(2)) SWIG_fail;
19492 if (arg1) (arg1)->m_rect = *arg2;
19493
19494 Py_INCREF(Py_None); resultobj = Py_None;
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19502 PyObject *resultobj;
19503 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19504 wxRect *result;
19505 PyObject * obj0 = 0 ;
19506 char *kwnames[] = {
19507 (char *) "self", NULL
19508 };
19509
19510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19512 if (SWIG_arg_fail(1)) SWIG_fail;
19513 result = (wxRect *)& ((arg1)->m_rect);
19514
19515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19523 PyObject *obj;
19524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19525 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19526 Py_INCREF(obj);
19527 return Py_BuildValue((char *)"");
19528 }
19529 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj;
19531 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19532 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19533 int arg2 = (int) 0 ;
19534 wxMoveEvent *result;
19535 wxPoint temp1 ;
19536 PyObject * obj0 = 0 ;
19537 PyObject * obj1 = 0 ;
19538 char *kwnames[] = {
19539 (char *) "pos",(char *) "winid", NULL
19540 };
19541
19542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19543 if (obj0) {
19544 {
19545 arg1 = &temp1;
19546 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19547 }
19548 }
19549 if (obj1) {
19550 {
19551 arg2 = (int)(SWIG_As_int(obj1));
19552 if (SWIG_arg_fail(2)) SWIG_fail;
19553 }
19554 }
19555 {
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19558
19559 wxPyEndAllowThreads(__tstate);
19560 if (PyErr_Occurred()) SWIG_fail;
19561 }
19562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19570 PyObject *resultobj;
19571 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19572 wxPoint result;
19573 PyObject * obj0 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "self", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = ((wxMoveEvent const *)arg1)->GetPosition();
19584
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 {
19589 wxPoint * resultptr;
19590 resultptr = new wxPoint((wxPoint &)(result));
19591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19602 wxRect result;
19603 PyObject * obj0 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = ((wxMoveEvent const *)arg1)->GetRect();
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 {
19619 wxRect * resultptr;
19620 resultptr = new wxRect((wxRect &)(result));
19621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19622 }
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj;
19631 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19632 wxRect *arg2 = 0 ;
19633 wxRect temp2 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 char *kwnames[] = {
19637 (char *) "self",(char *) "rect", NULL
19638 };
19639
19640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19642 if (SWIG_arg_fail(1)) SWIG_fail;
19643 {
19644 arg2 = &temp2;
19645 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19646 }
19647 {
19648 PyThreadState* __tstate = wxPyBeginAllowThreads();
19649 (arg1)->SetRect((wxRect const &)*arg2);
19650
19651 wxPyEndAllowThreads(__tstate);
19652 if (PyErr_Occurred()) SWIG_fail;
19653 }
19654 Py_INCREF(Py_None); resultobj = Py_None;
19655 return resultobj;
19656 fail:
19657 return NULL;
19658 }
19659
19660
19661 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19662 PyObject *resultobj;
19663 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19664 wxPoint *arg2 = 0 ;
19665 wxPoint temp2 ;
19666 PyObject * obj0 = 0 ;
19667 PyObject * obj1 = 0 ;
19668 char *kwnames[] = {
19669 (char *) "self",(char *) "pos", NULL
19670 };
19671
19672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19674 if (SWIG_arg_fail(1)) SWIG_fail;
19675 {
19676 arg2 = &temp2;
19677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19678 }
19679 {
19680 PyThreadState* __tstate = wxPyBeginAllowThreads();
19681 (arg1)->SetPosition((wxPoint const &)*arg2);
19682
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 Py_INCREF(Py_None); resultobj = Py_None;
19687 return resultobj;
19688 fail:
19689 return NULL;
19690 }
19691
19692
19693 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19694 PyObject *obj;
19695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19696 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19697 Py_INCREF(obj);
19698 return Py_BuildValue((char *)"");
19699 }
19700 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 int arg1 = (int) 0 ;
19703 wxPaintEvent *result;
19704 PyObject * obj0 = 0 ;
19705 char *kwnames[] = {
19706 (char *) "Id", NULL
19707 };
19708
19709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19710 if (obj0) {
19711 {
19712 arg1 = (int)(SWIG_As_int(obj0));
19713 if (SWIG_arg_fail(1)) SWIG_fail;
19714 }
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19719
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19731 PyObject *obj;
19732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19733 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19734 Py_INCREF(obj);
19735 return Py_BuildValue((char *)"");
19736 }
19737 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj;
19739 int arg1 = (int) 0 ;
19740 wxNcPaintEvent *result;
19741 PyObject * obj0 = 0 ;
19742 char *kwnames[] = {
19743 (char *) "winid", NULL
19744 };
19745
19746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19747 if (obj0) {
19748 {
19749 arg1 = (int)(SWIG_As_int(obj0));
19750 if (SWIG_arg_fail(1)) SWIG_fail;
19751 }
19752 }
19753 {
19754 PyThreadState* __tstate = wxPyBeginAllowThreads();
19755 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19756
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19768 PyObject *obj;
19769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19770 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19771 Py_INCREF(obj);
19772 return Py_BuildValue((char *)"");
19773 }
19774 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj;
19776 int arg1 = (int) 0 ;
19777 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19778 wxEraseEvent *result;
19779 PyObject * obj0 = 0 ;
19780 PyObject * obj1 = 0 ;
19781 char *kwnames[] = {
19782 (char *) "Id",(char *) "dc", NULL
19783 };
19784
19785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19786 if (obj0) {
19787 {
19788 arg1 = (int)(SWIG_As_int(obj0));
19789 if (SWIG_arg_fail(1)) SWIG_fail;
19790 }
19791 }
19792 if (obj1) {
19793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19794 if (SWIG_arg_fail(2)) SWIG_fail;
19795 }
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19799
19800 wxPyEndAllowThreads(__tstate);
19801 if (PyErr_Occurred()) SWIG_fail;
19802 }
19803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19804 return resultobj;
19805 fail:
19806 return NULL;
19807 }
19808
19809
19810 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19811 PyObject *resultobj;
19812 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19813 wxDC *result;
19814 PyObject * obj0 = 0 ;
19815 char *kwnames[] = {
19816 (char *) "self", NULL
19817 };
19818
19819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19821 if (SWIG_arg_fail(1)) SWIG_fail;
19822 {
19823 PyThreadState* __tstate = wxPyBeginAllowThreads();
19824 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19825
19826 wxPyEndAllowThreads(__tstate);
19827 if (PyErr_Occurred()) SWIG_fail;
19828 }
19829 {
19830 resultobj = wxPyMake_wxObject(result, 0);
19831 }
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19839 PyObject *obj;
19840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19841 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19842 Py_INCREF(obj);
19843 return Py_BuildValue((char *)"");
19844 }
19845 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19846 PyObject *resultobj;
19847 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19848 int arg2 = (int) 0 ;
19849 wxFocusEvent *result;
19850 PyObject * obj0 = 0 ;
19851 PyObject * obj1 = 0 ;
19852 char *kwnames[] = {
19853 (char *) "type",(char *) "winid", NULL
19854 };
19855
19856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19857 if (obj0) {
19858 {
19859 arg1 = (wxEventType)(SWIG_As_int(obj0));
19860 if (SWIG_arg_fail(1)) SWIG_fail;
19861 }
19862 }
19863 if (obj1) {
19864 {
19865 arg2 = (int)(SWIG_As_int(obj1));
19866 if (SWIG_arg_fail(2)) SWIG_fail;
19867 }
19868 }
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19872
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj;
19885 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19886 wxWindow *result;
19887 PyObject * obj0 = 0 ;
19888 char *kwnames[] = {
19889 (char *) "self", NULL
19890 };
19891
19892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19894 if (SWIG_arg_fail(1)) SWIG_fail;
19895 {
19896 PyThreadState* __tstate = wxPyBeginAllowThreads();
19897 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19898
19899 wxPyEndAllowThreads(__tstate);
19900 if (PyErr_Occurred()) SWIG_fail;
19901 }
19902 {
19903 resultobj = wxPyMake_wxObject(result, 0);
19904 }
19905 return resultobj;
19906 fail:
19907 return NULL;
19908 }
19909
19910
19911 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19912 PyObject *resultobj;
19913 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19914 wxWindow *arg2 = (wxWindow *) 0 ;
19915 PyObject * obj0 = 0 ;
19916 PyObject * obj1 = 0 ;
19917 char *kwnames[] = {
19918 (char *) "self",(char *) "win", NULL
19919 };
19920
19921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19923 if (SWIG_arg_fail(1)) SWIG_fail;
19924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19925 if (SWIG_arg_fail(2)) SWIG_fail;
19926 {
19927 PyThreadState* __tstate = wxPyBeginAllowThreads();
19928 (arg1)->SetWindow(arg2);
19929
19930 wxPyEndAllowThreads(__tstate);
19931 if (PyErr_Occurred()) SWIG_fail;
19932 }
19933 Py_INCREF(Py_None); resultobj = Py_None;
19934 return resultobj;
19935 fail:
19936 return NULL;
19937 }
19938
19939
19940 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19941 PyObject *obj;
19942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19943 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19944 Py_INCREF(obj);
19945 return Py_BuildValue((char *)"");
19946 }
19947 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj;
19949 wxWindow *arg1 = (wxWindow *) NULL ;
19950 wxChildFocusEvent *result;
19951 PyObject * obj0 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "win", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19957 if (obj0) {
19958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19959 if (SWIG_arg_fail(1)) SWIG_fail;
19960 }
19961 {
19962 PyThreadState* __tstate = wxPyBeginAllowThreads();
19963 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19964
19965 wxPyEndAllowThreads(__tstate);
19966 if (PyErr_Occurred()) SWIG_fail;
19967 }
19968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19969 return resultobj;
19970 fail:
19971 return NULL;
19972 }
19973
19974
19975 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj;
19977 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19978 wxWindow *result;
19979 PyObject * obj0 = 0 ;
19980 char *kwnames[] = {
19981 (char *) "self", NULL
19982 };
19983
19984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19986 if (SWIG_arg_fail(1)) SWIG_fail;
19987 {
19988 PyThreadState* __tstate = wxPyBeginAllowThreads();
19989 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19990
19991 wxPyEndAllowThreads(__tstate);
19992 if (PyErr_Occurred()) SWIG_fail;
19993 }
19994 {
19995 resultobj = wxPyMake_wxObject(result, 0);
19996 }
19997 return resultobj;
19998 fail:
19999 return NULL;
20000 }
20001
20002
20003 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20004 PyObject *obj;
20005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20006 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20007 Py_INCREF(obj);
20008 return Py_BuildValue((char *)"");
20009 }
20010 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20011 PyObject *resultobj;
20012 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20013 bool arg2 = (bool) true ;
20014 int arg3 = (int) 0 ;
20015 wxActivateEvent *result;
20016 PyObject * obj0 = 0 ;
20017 PyObject * obj1 = 0 ;
20018 PyObject * obj2 = 0 ;
20019 char *kwnames[] = {
20020 (char *) "type",(char *) "active",(char *) "Id", NULL
20021 };
20022
20023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20024 if (obj0) {
20025 {
20026 arg1 = (wxEventType)(SWIG_As_int(obj0));
20027 if (SWIG_arg_fail(1)) SWIG_fail;
20028 }
20029 }
20030 if (obj1) {
20031 {
20032 arg2 = (bool)(SWIG_As_bool(obj1));
20033 if (SWIG_arg_fail(2)) SWIG_fail;
20034 }
20035 }
20036 if (obj2) {
20037 {
20038 arg3 = (int)(SWIG_As_int(obj2));
20039 if (SWIG_arg_fail(3)) SWIG_fail;
20040 }
20041 }
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20045
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20057 PyObject *resultobj;
20058 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20059 bool result;
20060 PyObject * obj0 = 0 ;
20061 char *kwnames[] = {
20062 (char *) "self", NULL
20063 };
20064
20065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20067 if (SWIG_arg_fail(1)) SWIG_fail;
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20071
20072 wxPyEndAllowThreads(__tstate);
20073 if (PyErr_Occurred()) SWIG_fail;
20074 }
20075 {
20076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20077 }
20078 return resultobj;
20079 fail:
20080 return NULL;
20081 }
20082
20083
20084 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20085 PyObject *obj;
20086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20087 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20088 Py_INCREF(obj);
20089 return Py_BuildValue((char *)"");
20090 }
20091 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20092 PyObject *resultobj;
20093 int arg1 = (int) 0 ;
20094 wxInitDialogEvent *result;
20095 PyObject * obj0 = 0 ;
20096 char *kwnames[] = {
20097 (char *) "Id", NULL
20098 };
20099
20100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20101 if (obj0) {
20102 {
20103 arg1 = (int)(SWIG_As_int(obj0));
20104 if (SWIG_arg_fail(1)) SWIG_fail;
20105 }
20106 }
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20110
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20122 PyObject *obj;
20123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20124 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20125 Py_INCREF(obj);
20126 return Py_BuildValue((char *)"");
20127 }
20128 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20129 PyObject *resultobj;
20130 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20131 int arg2 = (int) 0 ;
20132 wxMenu *arg3 = (wxMenu *) NULL ;
20133 wxMenuEvent *result;
20134 PyObject * obj0 = 0 ;
20135 PyObject * obj1 = 0 ;
20136 PyObject * obj2 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "type",(char *) "winid",(char *) "menu", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20142 if (obj0) {
20143 {
20144 arg1 = (wxEventType)(SWIG_As_int(obj0));
20145 if (SWIG_arg_fail(1)) SWIG_fail;
20146 }
20147 }
20148 if (obj1) {
20149 {
20150 arg2 = (int)(SWIG_As_int(obj1));
20151 if (SWIG_arg_fail(2)) SWIG_fail;
20152 }
20153 }
20154 if (obj2) {
20155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20156 if (SWIG_arg_fail(3)) SWIG_fail;
20157 }
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20161
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20166 return resultobj;
20167 fail:
20168 return NULL;
20169 }
20170
20171
20172 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20173 PyObject *resultobj;
20174 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20175 int result;
20176 PyObject * obj0 = 0 ;
20177 char *kwnames[] = {
20178 (char *) "self", NULL
20179 };
20180
20181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20183 if (SWIG_arg_fail(1)) SWIG_fail;
20184 {
20185 PyThreadState* __tstate = wxPyBeginAllowThreads();
20186 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20187
20188 wxPyEndAllowThreads(__tstate);
20189 if (PyErr_Occurred()) SWIG_fail;
20190 }
20191 {
20192 resultobj = SWIG_From_int((int)(result));
20193 }
20194 return resultobj;
20195 fail:
20196 return NULL;
20197 }
20198
20199
20200 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20201 PyObject *resultobj;
20202 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20203 bool result;
20204 PyObject * obj0 = 0 ;
20205 char *kwnames[] = {
20206 (char *) "self", NULL
20207 };
20208
20209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20211 if (SWIG_arg_fail(1)) SWIG_fail;
20212 {
20213 PyThreadState* __tstate = wxPyBeginAllowThreads();
20214 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20215
20216 wxPyEndAllowThreads(__tstate);
20217 if (PyErr_Occurred()) SWIG_fail;
20218 }
20219 {
20220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20221 }
20222 return resultobj;
20223 fail:
20224 return NULL;
20225 }
20226
20227
20228 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20229 PyObject *resultobj;
20230 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20231 wxMenu *result;
20232 PyObject * obj0 = 0 ;
20233 char *kwnames[] = {
20234 (char *) "self", NULL
20235 };
20236
20237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20239 if (SWIG_arg_fail(1)) SWIG_fail;
20240 {
20241 PyThreadState* __tstate = wxPyBeginAllowThreads();
20242 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20243
20244 wxPyEndAllowThreads(__tstate);
20245 if (PyErr_Occurred()) SWIG_fail;
20246 }
20247 {
20248 resultobj = wxPyMake_wxObject(result, 0);
20249 }
20250 return resultobj;
20251 fail:
20252 return NULL;
20253 }
20254
20255
20256 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20257 PyObject *obj;
20258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20259 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20260 Py_INCREF(obj);
20261 return Py_BuildValue((char *)"");
20262 }
20263 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20264 PyObject *resultobj;
20265 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20266 int arg2 = (int) 0 ;
20267 wxCloseEvent *result;
20268 PyObject * obj0 = 0 ;
20269 PyObject * obj1 = 0 ;
20270 char *kwnames[] = {
20271 (char *) "type",(char *) "winid", NULL
20272 };
20273
20274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20275 if (obj0) {
20276 {
20277 arg1 = (wxEventType)(SWIG_As_int(obj0));
20278 if (SWIG_arg_fail(1)) SWIG_fail;
20279 }
20280 }
20281 if (obj1) {
20282 {
20283 arg2 = (int)(SWIG_As_int(obj1));
20284 if (SWIG_arg_fail(2)) SWIG_fail;
20285 }
20286 }
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20290
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj;
20303 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20304 bool arg2 ;
20305 PyObject * obj0 = 0 ;
20306 PyObject * obj1 = 0 ;
20307 char *kwnames[] = {
20308 (char *) "self",(char *) "logOff", NULL
20309 };
20310
20311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20313 if (SWIG_arg_fail(1)) SWIG_fail;
20314 {
20315 arg2 = (bool)(SWIG_As_bool(obj1));
20316 if (SWIG_arg_fail(2)) SWIG_fail;
20317 }
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 (arg1)->SetLoggingOff(arg2);
20321
20322 wxPyEndAllowThreads(__tstate);
20323 if (PyErr_Occurred()) SWIG_fail;
20324 }
20325 Py_INCREF(Py_None); resultobj = Py_None;
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20333 PyObject *resultobj;
20334 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20335 bool result;
20336 PyObject * obj0 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "self", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20347
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 {
20352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20353 }
20354 return resultobj;
20355 fail:
20356 return NULL;
20357 }
20358
20359
20360 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20361 PyObject *resultobj;
20362 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20363 bool arg2 = (bool) true ;
20364 PyObject * obj0 = 0 ;
20365 PyObject * obj1 = 0 ;
20366 char *kwnames[] = {
20367 (char *) "self",(char *) "veto", NULL
20368 };
20369
20370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20372 if (SWIG_arg_fail(1)) SWIG_fail;
20373 if (obj1) {
20374 {
20375 arg2 = (bool)(SWIG_As_bool(obj1));
20376 if (SWIG_arg_fail(2)) SWIG_fail;
20377 }
20378 }
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 (arg1)->Veto(arg2);
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 Py_INCREF(Py_None); resultobj = Py_None;
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj;
20395 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20396 bool arg2 ;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 char *kwnames[] = {
20400 (char *) "self",(char *) "canVeto", NULL
20401 };
20402
20403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20405 if (SWIG_arg_fail(1)) SWIG_fail;
20406 {
20407 arg2 = (bool)(SWIG_As_bool(obj1));
20408 if (SWIG_arg_fail(2)) SWIG_fail;
20409 }
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 (arg1)->SetCanVeto(arg2);
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 Py_INCREF(Py_None); resultobj = Py_None;
20418 return resultobj;
20419 fail:
20420 return NULL;
20421 }
20422
20423
20424 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj;
20426 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20427 bool result;
20428 PyObject * obj0 = 0 ;
20429 char *kwnames[] = {
20430 (char *) "self", NULL
20431 };
20432
20433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20435 if (SWIG_arg_fail(1)) SWIG_fail;
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20439
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20445 }
20446 return resultobj;
20447 fail:
20448 return NULL;
20449 }
20450
20451
20452 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20453 PyObject *resultobj;
20454 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20455 bool result;
20456 PyObject * obj0 = 0 ;
20457 char *kwnames[] = {
20458 (char *) "self", NULL
20459 };
20460
20461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20463 if (SWIG_arg_fail(1)) SWIG_fail;
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20467
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 {
20472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20473 }
20474 return resultobj;
20475 fail:
20476 return NULL;
20477 }
20478
20479
20480 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20481 PyObject *obj;
20482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20483 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20484 Py_INCREF(obj);
20485 return Py_BuildValue((char *)"");
20486 }
20487 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20488 PyObject *resultobj;
20489 int arg1 = (int) 0 ;
20490 bool arg2 = (bool) false ;
20491 wxShowEvent *result;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 char *kwnames[] = {
20495 (char *) "winid",(char *) "show", NULL
20496 };
20497
20498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20499 if (obj0) {
20500 {
20501 arg1 = (int)(SWIG_As_int(obj0));
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 }
20504 }
20505 if (obj1) {
20506 {
20507 arg2 = (bool)(SWIG_As_bool(obj1));
20508 if (SWIG_arg_fail(2)) SWIG_fail;
20509 }
20510 }
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20514
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20528 bool arg2 ;
20529 PyObject * obj0 = 0 ;
20530 PyObject * obj1 = 0 ;
20531 char *kwnames[] = {
20532 (char *) "self",(char *) "show", NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20537 if (SWIG_arg_fail(1)) SWIG_fail;
20538 {
20539 arg2 = (bool)(SWIG_As_bool(obj1));
20540 if (SWIG_arg_fail(2)) SWIG_fail;
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 (arg1)->SetShow(arg2);
20545
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 Py_INCREF(Py_None); resultobj = Py_None;
20550 return resultobj;
20551 fail:
20552 return NULL;
20553 }
20554
20555
20556 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj;
20558 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20559 bool result;
20560 PyObject * obj0 = 0 ;
20561 char *kwnames[] = {
20562 (char *) "self", NULL
20563 };
20564
20565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20567 if (SWIG_arg_fail(1)) SWIG_fail;
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20571
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 {
20576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20577 }
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20585 PyObject *obj;
20586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20587 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20588 Py_INCREF(obj);
20589 return Py_BuildValue((char *)"");
20590 }
20591 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20592 PyObject *resultobj;
20593 int arg1 = (int) 0 ;
20594 bool arg2 = (bool) true ;
20595 wxIconizeEvent *result;
20596 PyObject * obj0 = 0 ;
20597 PyObject * obj1 = 0 ;
20598 char *kwnames[] = {
20599 (char *) "id",(char *) "iconized", NULL
20600 };
20601
20602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20603 if (obj0) {
20604 {
20605 arg1 = (int)(SWIG_As_int(obj0));
20606 if (SWIG_arg_fail(1)) SWIG_fail;
20607 }
20608 }
20609 if (obj1) {
20610 {
20611 arg2 = (bool)(SWIG_As_bool(obj1));
20612 if (SWIG_arg_fail(2)) SWIG_fail;
20613 }
20614 }
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20618
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20623 return resultobj;
20624 fail:
20625 return NULL;
20626 }
20627
20628
20629 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20630 PyObject *resultobj;
20631 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20632 bool result;
20633 PyObject * obj0 = 0 ;
20634 char *kwnames[] = {
20635 (char *) "self", NULL
20636 };
20637
20638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20640 if (SWIG_arg_fail(1)) SWIG_fail;
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 result = (bool)(arg1)->Iconized();
20644
20645 wxPyEndAllowThreads(__tstate);
20646 if (PyErr_Occurred()) SWIG_fail;
20647 }
20648 {
20649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20650 }
20651 return resultobj;
20652 fail:
20653 return NULL;
20654 }
20655
20656
20657 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20658 PyObject *obj;
20659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20660 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20661 Py_INCREF(obj);
20662 return Py_BuildValue((char *)"");
20663 }
20664 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20665 PyObject *resultobj;
20666 int arg1 = (int) 0 ;
20667 wxMaximizeEvent *result;
20668 PyObject * obj0 = 0 ;
20669 char *kwnames[] = {
20670 (char *) "id", NULL
20671 };
20672
20673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20674 if (obj0) {
20675 {
20676 arg1 = (int)(SWIG_As_int(obj0));
20677 if (SWIG_arg_fail(1)) SWIG_fail;
20678 }
20679 }
20680 {
20681 PyThreadState* __tstate = wxPyBeginAllowThreads();
20682 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20683
20684 wxPyEndAllowThreads(__tstate);
20685 if (PyErr_Occurred()) SWIG_fail;
20686 }
20687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20688 return resultobj;
20689 fail:
20690 return NULL;
20691 }
20692
20693
20694 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20695 PyObject *obj;
20696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20697 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20698 Py_INCREF(obj);
20699 return Py_BuildValue((char *)"");
20700 }
20701 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj;
20703 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20704 wxPoint result;
20705 PyObject * obj0 = 0 ;
20706 char *kwnames[] = {
20707 (char *) "self", NULL
20708 };
20709
20710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20712 if (SWIG_arg_fail(1)) SWIG_fail;
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (arg1)->GetPosition();
20716
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 wxPoint * resultptr;
20722 resultptr = new wxPoint((wxPoint &)(result));
20723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20724 }
20725 return resultobj;
20726 fail:
20727 return NULL;
20728 }
20729
20730
20731 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20732 PyObject *resultobj;
20733 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20734 int result;
20735 PyObject * obj0 = 0 ;
20736 char *kwnames[] = {
20737 (char *) "self", NULL
20738 };
20739
20740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20742 if (SWIG_arg_fail(1)) SWIG_fail;
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (int)(arg1)->GetNumberOfFiles();
20746
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 {
20751 resultobj = SWIG_From_int((int)(result));
20752 }
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj;
20761 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20762 PyObject *result;
20763 PyObject * obj0 = 0 ;
20764 char *kwnames[] = {
20765 (char *) "self", NULL
20766 };
20767
20768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20770 if (SWIG_arg_fail(1)) SWIG_fail;
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20774
20775 wxPyEndAllowThreads(__tstate);
20776 if (PyErr_Occurred()) SWIG_fail;
20777 }
20778 resultobj = result;
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20786 PyObject *obj;
20787 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20788 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20789 Py_INCREF(obj);
20790 return Py_BuildValue((char *)"");
20791 }
20792 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20793 PyObject *resultobj;
20794 int arg1 = (int) 0 ;
20795 wxUpdateUIEvent *result;
20796 PyObject * obj0 = 0 ;
20797 char *kwnames[] = {
20798 (char *) "commandId", NULL
20799 };
20800
20801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20802 if (obj0) {
20803 {
20804 arg1 = (int)(SWIG_As_int(obj0));
20805 if (SWIG_arg_fail(1)) SWIG_fail;
20806 }
20807 }
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20811
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20816 return resultobj;
20817 fail:
20818 return NULL;
20819 }
20820
20821
20822 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20823 PyObject *resultobj;
20824 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20825 bool result;
20826 PyObject * obj0 = 0 ;
20827 char *kwnames[] = {
20828 (char *) "self", NULL
20829 };
20830
20831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20833 if (SWIG_arg_fail(1)) SWIG_fail;
20834 {
20835 PyThreadState* __tstate = wxPyBeginAllowThreads();
20836 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20837
20838 wxPyEndAllowThreads(__tstate);
20839 if (PyErr_Occurred()) SWIG_fail;
20840 }
20841 {
20842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20843 }
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20851 PyObject *resultobj;
20852 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20853 bool result;
20854 PyObject * obj0 = 0 ;
20855 char *kwnames[] = {
20856 (char *) "self", NULL
20857 };
20858
20859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20861 if (SWIG_arg_fail(1)) SWIG_fail;
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20865
20866 wxPyEndAllowThreads(__tstate);
20867 if (PyErr_Occurred()) SWIG_fail;
20868 }
20869 {
20870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20871 }
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20879 PyObject *resultobj;
20880 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20881 wxString result;
20882 PyObject * obj0 = 0 ;
20883 char *kwnames[] = {
20884 (char *) "self", NULL
20885 };
20886
20887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20889 if (SWIG_arg_fail(1)) SWIG_fail;
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20893
20894 wxPyEndAllowThreads(__tstate);
20895 if (PyErr_Occurred()) SWIG_fail;
20896 }
20897 {
20898 #if wxUSE_UNICODE
20899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20900 #else
20901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20902 #endif
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj;
20912 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20913 bool result;
20914 PyObject * obj0 = 0 ;
20915 char *kwnames[] = {
20916 (char *) "self", NULL
20917 };
20918
20919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20921 if (SWIG_arg_fail(1)) SWIG_fail;
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 {
20930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20931 }
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj;
20940 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20941 bool result;
20942 PyObject * obj0 = 0 ;
20943 char *kwnames[] = {
20944 (char *) "self", NULL
20945 };
20946
20947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20949 if (SWIG_arg_fail(1)) SWIG_fail;
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj;
20968 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20969 bool result;
20970 PyObject * obj0 = 0 ;
20971 char *kwnames[] = {
20972 (char *) "self", NULL
20973 };
20974
20975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20977 if (SWIG_arg_fail(1)) SWIG_fail;
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20981
20982 wxPyEndAllowThreads(__tstate);
20983 if (PyErr_Occurred()) SWIG_fail;
20984 }
20985 {
20986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20987 }
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20997 bool arg2 ;
20998 PyObject * obj0 = 0 ;
20999 PyObject * obj1 = 0 ;
21000 char *kwnames[] = {
21001 (char *) "self",(char *) "check", NULL
21002 };
21003
21004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21006 if (SWIG_arg_fail(1)) SWIG_fail;
21007 {
21008 arg2 = (bool)(SWIG_As_bool(obj1));
21009 if (SWIG_arg_fail(2)) SWIG_fail;
21010 }
21011 {
21012 PyThreadState* __tstate = wxPyBeginAllowThreads();
21013 (arg1)->Check(arg2);
21014
21015 wxPyEndAllowThreads(__tstate);
21016 if (PyErr_Occurred()) SWIG_fail;
21017 }
21018 Py_INCREF(Py_None); resultobj = Py_None;
21019 return resultobj;
21020 fail:
21021 return NULL;
21022 }
21023
21024
21025 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21026 PyObject *resultobj;
21027 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21028 bool arg2 ;
21029 PyObject * obj0 = 0 ;
21030 PyObject * obj1 = 0 ;
21031 char *kwnames[] = {
21032 (char *) "self",(char *) "enable", NULL
21033 };
21034
21035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21037 if (SWIG_arg_fail(1)) SWIG_fail;
21038 {
21039 arg2 = (bool)(SWIG_As_bool(obj1));
21040 if (SWIG_arg_fail(2)) SWIG_fail;
21041 }
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 (arg1)->Enable(arg2);
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 Py_INCREF(Py_None); resultobj = Py_None;
21050 return resultobj;
21051 fail:
21052 return NULL;
21053 }
21054
21055
21056 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21057 PyObject *resultobj;
21058 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21059 wxString *arg2 = 0 ;
21060 bool temp2 = false ;
21061 PyObject * obj0 = 0 ;
21062 PyObject * obj1 = 0 ;
21063 char *kwnames[] = {
21064 (char *) "self",(char *) "text", NULL
21065 };
21066
21067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21069 if (SWIG_arg_fail(1)) SWIG_fail;
21070 {
21071 arg2 = wxString_in_helper(obj1);
21072 if (arg2 == NULL) SWIG_fail;
21073 temp2 = true;
21074 }
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 (arg1)->SetText((wxString const &)*arg2);
21078
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 Py_INCREF(Py_None); resultobj = Py_None;
21083 {
21084 if (temp2)
21085 delete arg2;
21086 }
21087 return resultobj;
21088 fail:
21089 {
21090 if (temp2)
21091 delete arg2;
21092 }
21093 return NULL;
21094 }
21095
21096
21097 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj;
21099 long arg1 ;
21100 PyObject * obj0 = 0 ;
21101 char *kwnames[] = {
21102 (char *) "updateInterval", NULL
21103 };
21104
21105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21106 {
21107 arg1 = (long)(SWIG_As_long(obj0));
21108 if (SWIG_arg_fail(1)) SWIG_fail;
21109 }
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 wxUpdateUIEvent::SetUpdateInterval(arg1);
21113
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 Py_INCREF(Py_None); resultobj = Py_None;
21118 return resultobj;
21119 fail:
21120 return NULL;
21121 }
21122
21123
21124 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21125 PyObject *resultobj;
21126 long result;
21127 char *kwnames[] = {
21128 NULL
21129 };
21130
21131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21135
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 {
21140 resultobj = SWIG_From_long((long)(result));
21141 }
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21149 PyObject *resultobj;
21150 wxWindow *arg1 = (wxWindow *) 0 ;
21151 bool result;
21152 PyObject * obj0 = 0 ;
21153 char *kwnames[] = {
21154 (char *) "win", NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21159 if (SWIG_arg_fail(1)) SWIG_fail;
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21163
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21169 }
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj;
21178 char *kwnames[] = {
21179 NULL
21180 };
21181
21182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 wxUpdateUIEvent::ResetUpdateTime();
21186
21187 wxPyEndAllowThreads(__tstate);
21188 if (PyErr_Occurred()) SWIG_fail;
21189 }
21190 Py_INCREF(Py_None); resultobj = Py_None;
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21198 PyObject *resultobj;
21199 wxUpdateUIMode arg1 ;
21200 PyObject * obj0 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "mode", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21206 {
21207 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21208 if (SWIG_arg_fail(1)) SWIG_fail;
21209 }
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 Py_INCREF(Py_None); resultobj = Py_None;
21218 return resultobj;
21219 fail:
21220 return NULL;
21221 }
21222
21223
21224 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21225 PyObject *resultobj;
21226 wxUpdateUIMode result;
21227 char *kwnames[] = {
21228 NULL
21229 };
21230
21231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21235
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 resultobj = SWIG_From_int((result));
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21247 PyObject *obj;
21248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21249 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21250 Py_INCREF(obj);
21251 return Py_BuildValue((char *)"");
21252 }
21253 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj;
21255 wxSysColourChangedEvent *result;
21256 char *kwnames[] = {
21257 NULL
21258 };
21259
21260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21264
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21276 PyObject *obj;
21277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21278 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21279 Py_INCREF(obj);
21280 return Py_BuildValue((char *)"");
21281 }
21282 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21283 PyObject *resultobj;
21284 int arg1 = (int) 0 ;
21285 wxWindow *arg2 = (wxWindow *) NULL ;
21286 wxMouseCaptureChangedEvent *result;
21287 PyObject * obj0 = 0 ;
21288 PyObject * obj1 = 0 ;
21289 char *kwnames[] = {
21290 (char *) "winid",(char *) "gainedCapture", NULL
21291 };
21292
21293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21294 if (obj0) {
21295 {
21296 arg1 = (int)(SWIG_As_int(obj0));
21297 if (SWIG_arg_fail(1)) SWIG_fail;
21298 }
21299 }
21300 if (obj1) {
21301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21302 if (SWIG_arg_fail(2)) SWIG_fail;
21303 }
21304 {
21305 PyThreadState* __tstate = wxPyBeginAllowThreads();
21306 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21307
21308 wxPyEndAllowThreads(__tstate);
21309 if (PyErr_Occurred()) SWIG_fail;
21310 }
21311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21319 PyObject *resultobj;
21320 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21321 wxWindow *result;
21322 PyObject * obj0 = 0 ;
21323 char *kwnames[] = {
21324 (char *) "self", NULL
21325 };
21326
21327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21329 if (SWIG_arg_fail(1)) SWIG_fail;
21330 {
21331 PyThreadState* __tstate = wxPyBeginAllowThreads();
21332 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21333
21334 wxPyEndAllowThreads(__tstate);
21335 if (PyErr_Occurred()) SWIG_fail;
21336 }
21337 {
21338 resultobj = wxPyMake_wxObject(result, 0);
21339 }
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21347 PyObject *obj;
21348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21349 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21350 Py_INCREF(obj);
21351 return Py_BuildValue((char *)"");
21352 }
21353 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21354 PyObject *resultobj;
21355 wxDisplayChangedEvent *result;
21356 char *kwnames[] = {
21357 NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21361 {
21362 PyThreadState* __tstate = wxPyBeginAllowThreads();
21363 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21364
21365 wxPyEndAllowThreads(__tstate);
21366 if (PyErr_Occurred()) SWIG_fail;
21367 }
21368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21376 PyObject *obj;
21377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21378 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21379 Py_INCREF(obj);
21380 return Py_BuildValue((char *)"");
21381 }
21382 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj;
21384 int arg1 = (int) 0 ;
21385 wxPaletteChangedEvent *result;
21386 PyObject * obj0 = 0 ;
21387 char *kwnames[] = {
21388 (char *) "id", NULL
21389 };
21390
21391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21392 if (obj0) {
21393 {
21394 arg1 = (int)(SWIG_As_int(obj0));
21395 if (SWIG_arg_fail(1)) SWIG_fail;
21396 }
21397 }
21398 {
21399 PyThreadState* __tstate = wxPyBeginAllowThreads();
21400 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21401
21402 wxPyEndAllowThreads(__tstate);
21403 if (PyErr_Occurred()) SWIG_fail;
21404 }
21405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21413 PyObject *resultobj;
21414 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21415 wxWindow *arg2 = (wxWindow *) 0 ;
21416 PyObject * obj0 = 0 ;
21417 PyObject * obj1 = 0 ;
21418 char *kwnames[] = {
21419 (char *) "self",(char *) "win", NULL
21420 };
21421
21422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21424 if (SWIG_arg_fail(1)) SWIG_fail;
21425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21426 if (SWIG_arg_fail(2)) SWIG_fail;
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 (arg1)->SetChangedWindow(arg2);
21430
21431 wxPyEndAllowThreads(__tstate);
21432 if (PyErr_Occurred()) SWIG_fail;
21433 }
21434 Py_INCREF(Py_None); resultobj = Py_None;
21435 return resultobj;
21436 fail:
21437 return NULL;
21438 }
21439
21440
21441 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21442 PyObject *resultobj;
21443 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21444 wxWindow *result;
21445 PyObject * obj0 = 0 ;
21446 char *kwnames[] = {
21447 (char *) "self", NULL
21448 };
21449
21450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21452 if (SWIG_arg_fail(1)) SWIG_fail;
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (wxWindow *)(arg1)->GetChangedWindow();
21456
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 {
21461 resultobj = wxPyMake_wxObject(result, 0);
21462 }
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21470 PyObject *obj;
21471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21472 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21473 Py_INCREF(obj);
21474 return Py_BuildValue((char *)"");
21475 }
21476 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21477 PyObject *resultobj;
21478 int arg1 = (int) 0 ;
21479 wxQueryNewPaletteEvent *result;
21480 PyObject * obj0 = 0 ;
21481 char *kwnames[] = {
21482 (char *) "winid", NULL
21483 };
21484
21485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21486 if (obj0) {
21487 {
21488 arg1 = (int)(SWIG_As_int(obj0));
21489 if (SWIG_arg_fail(1)) SWIG_fail;
21490 }
21491 }
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21495
21496 wxPyEndAllowThreads(__tstate);
21497 if (PyErr_Occurred()) SWIG_fail;
21498 }
21499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj;
21508 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21509 bool arg2 ;
21510 PyObject * obj0 = 0 ;
21511 PyObject * obj1 = 0 ;
21512 char *kwnames[] = {
21513 (char *) "self",(char *) "realized", NULL
21514 };
21515
21516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21518 if (SWIG_arg_fail(1)) SWIG_fail;
21519 {
21520 arg2 = (bool)(SWIG_As_bool(obj1));
21521 if (SWIG_arg_fail(2)) SWIG_fail;
21522 }
21523 {
21524 PyThreadState* __tstate = wxPyBeginAllowThreads();
21525 (arg1)->SetPaletteRealized(arg2);
21526
21527 wxPyEndAllowThreads(__tstate);
21528 if (PyErr_Occurred()) SWIG_fail;
21529 }
21530 Py_INCREF(Py_None); resultobj = Py_None;
21531 return resultobj;
21532 fail:
21533 return NULL;
21534 }
21535
21536
21537 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21538 PyObject *resultobj;
21539 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21540 bool result;
21541 PyObject * obj0 = 0 ;
21542 char *kwnames[] = {
21543 (char *) "self", NULL
21544 };
21545
21546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21548 if (SWIG_arg_fail(1)) SWIG_fail;
21549 {
21550 PyThreadState* __tstate = wxPyBeginAllowThreads();
21551 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21552
21553 wxPyEndAllowThreads(__tstate);
21554 if (PyErr_Occurred()) SWIG_fail;
21555 }
21556 {
21557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21558 }
21559 return resultobj;
21560 fail:
21561 return NULL;
21562 }
21563
21564
21565 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21566 PyObject *obj;
21567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21568 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21569 Py_INCREF(obj);
21570 return Py_BuildValue((char *)"");
21571 }
21572 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21573 PyObject *resultobj;
21574 wxNavigationKeyEvent *result;
21575 char *kwnames[] = {
21576 NULL
21577 };
21578
21579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21580 {
21581 PyThreadState* __tstate = wxPyBeginAllowThreads();
21582 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21583
21584 wxPyEndAllowThreads(__tstate);
21585 if (PyErr_Occurred()) SWIG_fail;
21586 }
21587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21588 return resultobj;
21589 fail:
21590 return NULL;
21591 }
21592
21593
21594 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21595 PyObject *resultobj;
21596 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21597 bool result;
21598 PyObject * obj0 = 0 ;
21599 char *kwnames[] = {
21600 (char *) "self", NULL
21601 };
21602
21603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21605 if (SWIG_arg_fail(1)) SWIG_fail;
21606 {
21607 PyThreadState* __tstate = wxPyBeginAllowThreads();
21608 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21609
21610 wxPyEndAllowThreads(__tstate);
21611 if (PyErr_Occurred()) SWIG_fail;
21612 }
21613 {
21614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21615 }
21616 return resultobj;
21617 fail:
21618 return NULL;
21619 }
21620
21621
21622 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj;
21624 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21625 bool arg2 ;
21626 PyObject * obj0 = 0 ;
21627 PyObject * obj1 = 0 ;
21628 char *kwnames[] = {
21629 (char *) "self",(char *) "forward", NULL
21630 };
21631
21632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21634 if (SWIG_arg_fail(1)) SWIG_fail;
21635 {
21636 arg2 = (bool)(SWIG_As_bool(obj1));
21637 if (SWIG_arg_fail(2)) SWIG_fail;
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 (arg1)->SetDirection(arg2);
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 Py_INCREF(Py_None); resultobj = Py_None;
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21654 PyObject *resultobj;
21655 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21656 bool result;
21657 PyObject * obj0 = 0 ;
21658 char *kwnames[] = {
21659 (char *) "self", NULL
21660 };
21661
21662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21664 if (SWIG_arg_fail(1)) SWIG_fail;
21665 {
21666 PyThreadState* __tstate = wxPyBeginAllowThreads();
21667 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21668
21669 wxPyEndAllowThreads(__tstate);
21670 if (PyErr_Occurred()) SWIG_fail;
21671 }
21672 {
21673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21674 }
21675 return resultobj;
21676 fail:
21677 return NULL;
21678 }
21679
21680
21681 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21682 PyObject *resultobj;
21683 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21684 bool arg2 ;
21685 PyObject * obj0 = 0 ;
21686 PyObject * obj1 = 0 ;
21687 char *kwnames[] = {
21688 (char *) "self",(char *) "ischange", NULL
21689 };
21690
21691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21693 if (SWIG_arg_fail(1)) SWIG_fail;
21694 {
21695 arg2 = (bool)(SWIG_As_bool(obj1));
21696 if (SWIG_arg_fail(2)) SWIG_fail;
21697 }
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 (arg1)->SetWindowChange(arg2);
21701
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 Py_INCREF(Py_None); resultobj = Py_None;
21706 return resultobj;
21707 fail:
21708 return NULL;
21709 }
21710
21711
21712 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21713 PyObject *resultobj;
21714 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21715 bool result;
21716 PyObject * obj0 = 0 ;
21717 char *kwnames[] = {
21718 (char *) "self", NULL
21719 };
21720
21721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21723 if (SWIG_arg_fail(1)) SWIG_fail;
21724 {
21725 PyThreadState* __tstate = wxPyBeginAllowThreads();
21726 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21727
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 {
21732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21733 }
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21741 PyObject *resultobj;
21742 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21743 bool arg2 ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "self",(char *) "bIs", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21752 if (SWIG_arg_fail(1)) SWIG_fail;
21753 {
21754 arg2 = (bool)(SWIG_As_bool(obj1));
21755 if (SWIG_arg_fail(2)) SWIG_fail;
21756 }
21757 {
21758 PyThreadState* __tstate = wxPyBeginAllowThreads();
21759 (arg1)->SetFromTab(arg2);
21760
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 Py_INCREF(Py_None); resultobj = Py_None;
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21772 PyObject *resultobj;
21773 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21774 long arg2 ;
21775 PyObject * obj0 = 0 ;
21776 PyObject * obj1 = 0 ;
21777 char *kwnames[] = {
21778 (char *) "self",(char *) "flags", NULL
21779 };
21780
21781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21783 if (SWIG_arg_fail(1)) SWIG_fail;
21784 {
21785 arg2 = (long)(SWIG_As_long(obj1));
21786 if (SWIG_arg_fail(2)) SWIG_fail;
21787 }
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 (arg1)->SetFlags(arg2);
21791
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 Py_INCREF(Py_None); resultobj = Py_None;
21796 return resultobj;
21797 fail:
21798 return NULL;
21799 }
21800
21801
21802 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21803 PyObject *resultobj;
21804 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21805 wxWindow *result;
21806 PyObject * obj0 = 0 ;
21807 char *kwnames[] = {
21808 (char *) "self", NULL
21809 };
21810
21811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21813 if (SWIG_arg_fail(1)) SWIG_fail;
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21817
21818 wxPyEndAllowThreads(__tstate);
21819 if (PyErr_Occurred()) SWIG_fail;
21820 }
21821 {
21822 resultobj = wxPyMake_wxObject(result, 0);
21823 }
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21833 wxWindow *arg2 = (wxWindow *) 0 ;
21834 PyObject * obj0 = 0 ;
21835 PyObject * obj1 = 0 ;
21836 char *kwnames[] = {
21837 (char *) "self",(char *) "win", NULL
21838 };
21839
21840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21842 if (SWIG_arg_fail(1)) SWIG_fail;
21843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21844 if (SWIG_arg_fail(2)) SWIG_fail;
21845 {
21846 PyThreadState* __tstate = wxPyBeginAllowThreads();
21847 (arg1)->SetCurrentFocus(arg2);
21848
21849 wxPyEndAllowThreads(__tstate);
21850 if (PyErr_Occurred()) SWIG_fail;
21851 }
21852 Py_INCREF(Py_None); resultobj = Py_None;
21853 return resultobj;
21854 fail:
21855 return NULL;
21856 }
21857
21858
21859 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21860 PyObject *obj;
21861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21862 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21863 Py_INCREF(obj);
21864 return Py_BuildValue((char *)"");
21865 }
21866 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21867 PyObject *resultobj;
21868 wxWindow *arg1 = (wxWindow *) NULL ;
21869 wxWindowCreateEvent *result;
21870 PyObject * obj0 = 0 ;
21871 char *kwnames[] = {
21872 (char *) "win", NULL
21873 };
21874
21875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21876 if (obj0) {
21877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21878 if (SWIG_arg_fail(1)) SWIG_fail;
21879 }
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21883
21884 wxPyEndAllowThreads(__tstate);
21885 if (PyErr_Occurred()) SWIG_fail;
21886 }
21887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21888 return resultobj;
21889 fail:
21890 return NULL;
21891 }
21892
21893
21894 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21895 PyObject *resultobj;
21896 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21897 wxWindow *result;
21898 PyObject * obj0 = 0 ;
21899 char *kwnames[] = {
21900 (char *) "self", NULL
21901 };
21902
21903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21905 if (SWIG_arg_fail(1)) SWIG_fail;
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21909
21910 wxPyEndAllowThreads(__tstate);
21911 if (PyErr_Occurred()) SWIG_fail;
21912 }
21913 {
21914 resultobj = wxPyMake_wxObject(result, 0);
21915 }
21916 return resultobj;
21917 fail:
21918 return NULL;
21919 }
21920
21921
21922 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21923 PyObject *obj;
21924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21925 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21926 Py_INCREF(obj);
21927 return Py_BuildValue((char *)"");
21928 }
21929 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21930 PyObject *resultobj;
21931 wxWindow *arg1 = (wxWindow *) NULL ;
21932 wxWindowDestroyEvent *result;
21933 PyObject * obj0 = 0 ;
21934 char *kwnames[] = {
21935 (char *) "win", NULL
21936 };
21937
21938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21939 if (obj0) {
21940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21941 if (SWIG_arg_fail(1)) SWIG_fail;
21942 }
21943 {
21944 PyThreadState* __tstate = wxPyBeginAllowThreads();
21945 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21946
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21958 PyObject *resultobj;
21959 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21960 wxWindow *result;
21961 PyObject * obj0 = 0 ;
21962 char *kwnames[] = {
21963 (char *) "self", NULL
21964 };
21965
21966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21968 if (SWIG_arg_fail(1)) SWIG_fail;
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21972
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 {
21977 resultobj = wxPyMake_wxObject(result, 0);
21978 }
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21986 PyObject *obj;
21987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21988 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21989 Py_INCREF(obj);
21990 return Py_BuildValue((char *)"");
21991 }
21992 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21993 PyObject *resultobj;
21994 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21995 int arg2 = (int) 0 ;
21996 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21997 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21998 wxContextMenuEvent *result;
21999 wxPoint temp3 ;
22000 PyObject * obj0 = 0 ;
22001 PyObject * obj1 = 0 ;
22002 PyObject * obj2 = 0 ;
22003 char *kwnames[] = {
22004 (char *) "type",(char *) "winid",(char *) "pt", NULL
22005 };
22006
22007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22008 if (obj0) {
22009 {
22010 arg1 = (wxEventType)(SWIG_As_int(obj0));
22011 if (SWIG_arg_fail(1)) SWIG_fail;
22012 }
22013 }
22014 if (obj1) {
22015 {
22016 arg2 = (int)(SWIG_As_int(obj1));
22017 if (SWIG_arg_fail(2)) SWIG_fail;
22018 }
22019 }
22020 if (obj2) {
22021 {
22022 arg3 = &temp3;
22023 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22024 }
22025 }
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22029
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22034 return resultobj;
22035 fail:
22036 return NULL;
22037 }
22038
22039
22040 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22041 PyObject *resultobj;
22042 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22043 wxPoint *result;
22044 PyObject * obj0 = 0 ;
22045 char *kwnames[] = {
22046 (char *) "self", NULL
22047 };
22048
22049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22051 if (SWIG_arg_fail(1)) SWIG_fail;
22052 {
22053 PyThreadState* __tstate = wxPyBeginAllowThreads();
22054 {
22055 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22056 result = (wxPoint *) &_result_ref;
22057 }
22058
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj;
22071 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22072 wxPoint *arg2 = 0 ;
22073 wxPoint temp2 ;
22074 PyObject * obj0 = 0 ;
22075 PyObject * obj1 = 0 ;
22076 char *kwnames[] = {
22077 (char *) "self",(char *) "pos", NULL
22078 };
22079
22080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22082 if (SWIG_arg_fail(1)) SWIG_fail;
22083 {
22084 arg2 = &temp2;
22085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22086 }
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 (arg1)->SetPosition((wxPoint const &)*arg2);
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 Py_INCREF(Py_None); resultobj = Py_None;
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22102 PyObject *obj;
22103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22104 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22105 Py_INCREF(obj);
22106 return Py_BuildValue((char *)"");
22107 }
22108 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22109 PyObject *resultobj;
22110 wxIdleEvent *result;
22111 char *kwnames[] = {
22112 NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (wxIdleEvent *)new wxIdleEvent();
22119
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22131 PyObject *resultobj;
22132 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22133 bool arg2 = (bool) true ;
22134 PyObject * obj0 = 0 ;
22135 PyObject * obj1 = 0 ;
22136 char *kwnames[] = {
22137 (char *) "self",(char *) "needMore", NULL
22138 };
22139
22140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22142 if (SWIG_arg_fail(1)) SWIG_fail;
22143 if (obj1) {
22144 {
22145 arg2 = (bool)(SWIG_As_bool(obj1));
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 }
22148 }
22149 {
22150 PyThreadState* __tstate = wxPyBeginAllowThreads();
22151 (arg1)->RequestMore(arg2);
22152
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 Py_INCREF(Py_None); resultobj = Py_None;
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj;
22165 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22166 bool result;
22167 PyObject * obj0 = 0 ;
22168 char *kwnames[] = {
22169 (char *) "self", NULL
22170 };
22171
22172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22174 if (SWIG_arg_fail(1)) SWIG_fail;
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22178
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 {
22183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22184 }
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22192 PyObject *resultobj;
22193 wxIdleMode arg1 ;
22194 PyObject * obj0 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "mode", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22200 {
22201 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22202 if (SWIG_arg_fail(1)) SWIG_fail;
22203 }
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 wxIdleEvent::SetMode((wxIdleMode )arg1);
22207
22208 wxPyEndAllowThreads(__tstate);
22209 if (PyErr_Occurred()) SWIG_fail;
22210 }
22211 Py_INCREF(Py_None); resultobj = Py_None;
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22219 PyObject *resultobj;
22220 wxIdleMode result;
22221 char *kwnames[] = {
22222 NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22226 {
22227 PyThreadState* __tstate = wxPyBeginAllowThreads();
22228 result = (wxIdleMode)wxIdleEvent::GetMode();
22229
22230 wxPyEndAllowThreads(__tstate);
22231 if (PyErr_Occurred()) SWIG_fail;
22232 }
22233 resultobj = SWIG_From_int((result));
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22241 PyObject *resultobj;
22242 wxWindow *arg1 = (wxWindow *) 0 ;
22243 bool result;
22244 PyObject * obj0 = 0 ;
22245 char *kwnames[] = {
22246 (char *) "win", NULL
22247 };
22248
22249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22251 if (SWIG_arg_fail(1)) SWIG_fail;
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 result = (bool)wxIdleEvent::CanSend(arg1);
22255
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22261 }
22262 return resultobj;
22263 fail:
22264 return NULL;
22265 }
22266
22267
22268 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22269 PyObject *obj;
22270 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22271 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22272 Py_INCREF(obj);
22273 return Py_BuildValue((char *)"");
22274 }
22275 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj;
22277 int arg1 = (int) 0 ;
22278 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22279 wxPyEvent *result;
22280 PyObject * obj0 = 0 ;
22281 PyObject * obj1 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "winid",(char *) "commandType", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22287 if (obj0) {
22288 {
22289 arg1 = (int)(SWIG_As_int(obj0));
22290 if (SWIG_arg_fail(1)) SWIG_fail;
22291 }
22292 }
22293 if (obj1) {
22294 {
22295 arg2 = (wxEventType)(SWIG_As_int(obj1));
22296 if (SWIG_arg_fail(2)) SWIG_fail;
22297 }
22298 }
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22302
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj;
22315 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22316 PyObject * obj0 = 0 ;
22317 char *kwnames[] = {
22318 (char *) "self", NULL
22319 };
22320
22321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22323 if (SWIG_arg_fail(1)) SWIG_fail;
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 delete arg1;
22327
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 Py_INCREF(Py_None); resultobj = Py_None;
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj;
22340 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22341 PyObject *arg2 = (PyObject *) 0 ;
22342 PyObject * obj0 = 0 ;
22343 PyObject * obj1 = 0 ;
22344 char *kwnames[] = {
22345 (char *) "self",(char *) "self", NULL
22346 };
22347
22348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22350 if (SWIG_arg_fail(1)) SWIG_fail;
22351 arg2 = obj1;
22352 {
22353 PyThreadState* __tstate = wxPyBeginAllowThreads();
22354 (arg1)->SetSelf(arg2);
22355
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 Py_INCREF(Py_None); resultobj = Py_None;
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22367 PyObject *resultobj;
22368 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22369 PyObject *result;
22370 PyObject * obj0 = 0 ;
22371 char *kwnames[] = {
22372 (char *) "self", NULL
22373 };
22374
22375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22377 if (SWIG_arg_fail(1)) SWIG_fail;
22378 {
22379 PyThreadState* __tstate = wxPyBeginAllowThreads();
22380 result = (PyObject *)(arg1)->GetSelf();
22381
22382 wxPyEndAllowThreads(__tstate);
22383 if (PyErr_Occurred()) SWIG_fail;
22384 }
22385 resultobj = result;
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22393 PyObject *obj;
22394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22395 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22396 Py_INCREF(obj);
22397 return Py_BuildValue((char *)"");
22398 }
22399 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22400 PyObject *resultobj;
22401 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22402 int arg2 = (int) 0 ;
22403 wxPyCommandEvent *result;
22404 PyObject * obj0 = 0 ;
22405 PyObject * obj1 = 0 ;
22406 char *kwnames[] = {
22407 (char *) "commandType",(char *) "id", NULL
22408 };
22409
22410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22411 if (obj0) {
22412 {
22413 arg1 = (wxEventType)(SWIG_As_int(obj0));
22414 if (SWIG_arg_fail(1)) SWIG_fail;
22415 }
22416 }
22417 if (obj1) {
22418 {
22419 arg2 = (int)(SWIG_As_int(obj1));
22420 if (SWIG_arg_fail(2)) SWIG_fail;
22421 }
22422 }
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22426
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22431 return resultobj;
22432 fail:
22433 return NULL;
22434 }
22435
22436
22437 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22438 PyObject *resultobj;
22439 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22440 PyObject * obj0 = 0 ;
22441 char *kwnames[] = {
22442 (char *) "self", NULL
22443 };
22444
22445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22447 if (SWIG_arg_fail(1)) SWIG_fail;
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 delete arg1;
22451
22452 wxPyEndAllowThreads(__tstate);
22453 if (PyErr_Occurred()) SWIG_fail;
22454 }
22455 Py_INCREF(Py_None); resultobj = Py_None;
22456 return resultobj;
22457 fail:
22458 return NULL;
22459 }
22460
22461
22462 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22463 PyObject *resultobj;
22464 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22465 PyObject *arg2 = (PyObject *) 0 ;
22466 PyObject * obj0 = 0 ;
22467 PyObject * obj1 = 0 ;
22468 char *kwnames[] = {
22469 (char *) "self",(char *) "self", NULL
22470 };
22471
22472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 arg2 = obj1;
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 (arg1)->SetSelf(arg2);
22479
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 Py_INCREF(Py_None); resultobj = Py_None;
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22491 PyObject *resultobj;
22492 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22493 PyObject *result;
22494 PyObject * obj0 = 0 ;
22495 char *kwnames[] = {
22496 (char *) "self", NULL
22497 };
22498
22499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22501 if (SWIG_arg_fail(1)) SWIG_fail;
22502 {
22503 PyThreadState* __tstate = wxPyBeginAllowThreads();
22504 result = (PyObject *)(arg1)->GetSelf();
22505
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 resultobj = result;
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22517 PyObject *obj;
22518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22519 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22520 Py_INCREF(obj);
22521 return Py_BuildValue((char *)"");
22522 }
22523 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj;
22525 wxWindow *arg1 = (wxWindow *) 0 ;
22526 wxDateTime *arg2 = 0 ;
22527 wxEventType arg3 ;
22528 wxDateEvent *result;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 PyObject * obj2 = 0 ;
22532 char *kwnames[] = {
22533 (char *) "win",(char *) "dt",(char *) "type", NULL
22534 };
22535
22536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22538 if (SWIG_arg_fail(1)) SWIG_fail;
22539 {
22540 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22541 if (SWIG_arg_fail(2)) SWIG_fail;
22542 if (arg2 == NULL) {
22543 SWIG_null_ref("wxDateTime");
22544 }
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 }
22547 {
22548 arg3 = (wxEventType)(SWIG_As_int(obj2));
22549 if (SWIG_arg_fail(3)) SWIG_fail;
22550 }
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22554
22555 wxPyEndAllowThreads(__tstate);
22556 if (PyErr_Occurred()) SWIG_fail;
22557 }
22558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22559 return resultobj;
22560 fail:
22561 return NULL;
22562 }
22563
22564
22565 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22566 PyObject *resultobj;
22567 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22568 wxDateTime *result;
22569 PyObject * obj0 = 0 ;
22570 char *kwnames[] = {
22571 (char *) "self", NULL
22572 };
22573
22574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22576 if (SWIG_arg_fail(1)) SWIG_fail;
22577 {
22578 PyThreadState* __tstate = wxPyBeginAllowThreads();
22579 {
22580 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22581 result = (wxDateTime *) &_result_ref;
22582 }
22583
22584 wxPyEndAllowThreads(__tstate);
22585 if (PyErr_Occurred()) SWIG_fail;
22586 }
22587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22595 PyObject *resultobj;
22596 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22597 wxDateTime *arg2 = 0 ;
22598 PyObject * obj0 = 0 ;
22599 PyObject * obj1 = 0 ;
22600 char *kwnames[] = {
22601 (char *) "self",(char *) "date", NULL
22602 };
22603
22604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22606 if (SWIG_arg_fail(1)) SWIG_fail;
22607 {
22608 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22609 if (SWIG_arg_fail(2)) SWIG_fail;
22610 if (arg2 == NULL) {
22611 SWIG_null_ref("wxDateTime");
22612 }
22613 if (SWIG_arg_fail(2)) SWIG_fail;
22614 }
22615 {
22616 PyThreadState* __tstate = wxPyBeginAllowThreads();
22617 (arg1)->SetDate((wxDateTime const &)*arg2);
22618
22619 wxPyEndAllowThreads(__tstate);
22620 if (PyErr_Occurred()) SWIG_fail;
22621 }
22622 Py_INCREF(Py_None); resultobj = Py_None;
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22630 PyObject *obj;
22631 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22632 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22633 Py_INCREF(obj);
22634 return Py_BuildValue((char *)"");
22635 }
22636 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22637 PyObject *resultobj;
22638 wxPyApp *result;
22639 char *kwnames[] = {
22640 NULL
22641 };
22642
22643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 result = (wxPyApp *)new_wxPyApp();
22647
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22659 PyObject *resultobj;
22660 wxPyApp *arg1 = (wxPyApp *) 0 ;
22661 PyObject * obj0 = 0 ;
22662 char *kwnames[] = {
22663 (char *) "self", NULL
22664 };
22665
22666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22668 if (SWIG_arg_fail(1)) SWIG_fail;
22669 {
22670 PyThreadState* __tstate = wxPyBeginAllowThreads();
22671 delete arg1;
22672
22673 wxPyEndAllowThreads(__tstate);
22674 if (PyErr_Occurred()) SWIG_fail;
22675 }
22676 Py_INCREF(Py_None); resultobj = Py_None;
22677 return resultobj;
22678 fail:
22679 return NULL;
22680 }
22681
22682
22683 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22684 PyObject *resultobj;
22685 wxPyApp *arg1 = (wxPyApp *) 0 ;
22686 PyObject *arg2 = (PyObject *) 0 ;
22687 PyObject *arg3 = (PyObject *) 0 ;
22688 bool arg4 ;
22689 PyObject * obj0 = 0 ;
22690 PyObject * obj1 = 0 ;
22691 PyObject * obj2 = 0 ;
22692 PyObject * obj3 = 0 ;
22693 char *kwnames[] = {
22694 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22695 };
22696
22697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22699 if (SWIG_arg_fail(1)) SWIG_fail;
22700 arg2 = obj1;
22701 arg3 = obj2;
22702 {
22703 arg4 = (bool)(SWIG_As_bool(obj3));
22704 if (SWIG_arg_fail(4)) SWIG_fail;
22705 }
22706 {
22707 PyThreadState* __tstate = wxPyBeginAllowThreads();
22708 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22709
22710 wxPyEndAllowThreads(__tstate);
22711 if (PyErr_Occurred()) SWIG_fail;
22712 }
22713 Py_INCREF(Py_None); resultobj = Py_None;
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj;
22722 wxPyApp *arg1 = (wxPyApp *) 0 ;
22723 wxString result;
22724 PyObject * obj0 = 0 ;
22725 char *kwnames[] = {
22726 (char *) "self", NULL
22727 };
22728
22729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22731 if (SWIG_arg_fail(1)) SWIG_fail;
22732 {
22733 PyThreadState* __tstate = wxPyBeginAllowThreads();
22734 result = ((wxPyApp const *)arg1)->GetAppName();
22735
22736 wxPyEndAllowThreads(__tstate);
22737 if (PyErr_Occurred()) SWIG_fail;
22738 }
22739 {
22740 #if wxUSE_UNICODE
22741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22742 #else
22743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22744 #endif
22745 }
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22753 PyObject *resultobj;
22754 wxPyApp *arg1 = (wxPyApp *) 0 ;
22755 wxString *arg2 = 0 ;
22756 bool temp2 = false ;
22757 PyObject * obj0 = 0 ;
22758 PyObject * obj1 = 0 ;
22759 char *kwnames[] = {
22760 (char *) "self",(char *) "name", NULL
22761 };
22762
22763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22765 if (SWIG_arg_fail(1)) SWIG_fail;
22766 {
22767 arg2 = wxString_in_helper(obj1);
22768 if (arg2 == NULL) SWIG_fail;
22769 temp2 = true;
22770 }
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 (arg1)->SetAppName((wxString const &)*arg2);
22774
22775 wxPyEndAllowThreads(__tstate);
22776 if (PyErr_Occurred()) SWIG_fail;
22777 }
22778 Py_INCREF(Py_None); resultobj = Py_None;
22779 {
22780 if (temp2)
22781 delete arg2;
22782 }
22783 return resultobj;
22784 fail:
22785 {
22786 if (temp2)
22787 delete arg2;
22788 }
22789 return NULL;
22790 }
22791
22792
22793 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22794 PyObject *resultobj;
22795 wxPyApp *arg1 = (wxPyApp *) 0 ;
22796 wxString result;
22797 PyObject * obj0 = 0 ;
22798 char *kwnames[] = {
22799 (char *) "self", NULL
22800 };
22801
22802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22804 if (SWIG_arg_fail(1)) SWIG_fail;
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 result = ((wxPyApp const *)arg1)->GetClassName();
22808
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 {
22813 #if wxUSE_UNICODE
22814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22815 #else
22816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22817 #endif
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22826 PyObject *resultobj;
22827 wxPyApp *arg1 = (wxPyApp *) 0 ;
22828 wxString *arg2 = 0 ;
22829 bool temp2 = false ;
22830 PyObject * obj0 = 0 ;
22831 PyObject * obj1 = 0 ;
22832 char *kwnames[] = {
22833 (char *) "self",(char *) "name", NULL
22834 };
22835
22836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22838 if (SWIG_arg_fail(1)) SWIG_fail;
22839 {
22840 arg2 = wxString_in_helper(obj1);
22841 if (arg2 == NULL) SWIG_fail;
22842 temp2 = true;
22843 }
22844 {
22845 PyThreadState* __tstate = wxPyBeginAllowThreads();
22846 (arg1)->SetClassName((wxString const &)*arg2);
22847
22848 wxPyEndAllowThreads(__tstate);
22849 if (PyErr_Occurred()) SWIG_fail;
22850 }
22851 Py_INCREF(Py_None); resultobj = Py_None;
22852 {
22853 if (temp2)
22854 delete arg2;
22855 }
22856 return resultobj;
22857 fail:
22858 {
22859 if (temp2)
22860 delete arg2;
22861 }
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj;
22868 wxPyApp *arg1 = (wxPyApp *) 0 ;
22869 wxString *result;
22870 PyObject * obj0 = 0 ;
22871 char *kwnames[] = {
22872 (char *) "self", NULL
22873 };
22874
22875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22877 if (SWIG_arg_fail(1)) SWIG_fail;
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 {
22881 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22882 result = (wxString *) &_result_ref;
22883 }
22884
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 {
22889 #if wxUSE_UNICODE
22890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22891 #else
22892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22893 #endif
22894 }
22895 return resultobj;
22896 fail:
22897 return NULL;
22898 }
22899
22900
22901 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22902 PyObject *resultobj;
22903 wxPyApp *arg1 = (wxPyApp *) 0 ;
22904 wxString *arg2 = 0 ;
22905 bool temp2 = false ;
22906 PyObject * obj0 = 0 ;
22907 PyObject * obj1 = 0 ;
22908 char *kwnames[] = {
22909 (char *) "self",(char *) "name", NULL
22910 };
22911
22912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22914 if (SWIG_arg_fail(1)) SWIG_fail;
22915 {
22916 arg2 = wxString_in_helper(obj1);
22917 if (arg2 == NULL) SWIG_fail;
22918 temp2 = true;
22919 }
22920 {
22921 PyThreadState* __tstate = wxPyBeginAllowThreads();
22922 (arg1)->SetVendorName((wxString const &)*arg2);
22923
22924 wxPyEndAllowThreads(__tstate);
22925 if (PyErr_Occurred()) SWIG_fail;
22926 }
22927 Py_INCREF(Py_None); resultobj = Py_None;
22928 {
22929 if (temp2)
22930 delete arg2;
22931 }
22932 return resultobj;
22933 fail:
22934 {
22935 if (temp2)
22936 delete arg2;
22937 }
22938 return NULL;
22939 }
22940
22941
22942 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22943 PyObject *resultobj;
22944 wxPyApp *arg1 = (wxPyApp *) 0 ;
22945 wxAppTraits *result;
22946 PyObject * obj0 = 0 ;
22947 char *kwnames[] = {
22948 (char *) "self", NULL
22949 };
22950
22951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22953 if (SWIG_arg_fail(1)) SWIG_fail;
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 result = (wxAppTraits *)(arg1)->GetTraits();
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj;
22970 wxPyApp *arg1 = (wxPyApp *) 0 ;
22971 PyObject * obj0 = 0 ;
22972 char *kwnames[] = {
22973 (char *) "self", NULL
22974 };
22975
22976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22978 if (SWIG_arg_fail(1)) SWIG_fail;
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 (arg1)->ProcessPendingEvents();
22982
22983 wxPyEndAllowThreads(__tstate);
22984 if (PyErr_Occurred()) SWIG_fail;
22985 }
22986 Py_INCREF(Py_None); resultobj = Py_None;
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22994 PyObject *resultobj;
22995 wxPyApp *arg1 = (wxPyApp *) 0 ;
22996 bool arg2 = (bool) false ;
22997 bool result;
22998 PyObject * obj0 = 0 ;
22999 PyObject * obj1 = 0 ;
23000 char *kwnames[] = {
23001 (char *) "self",(char *) "onlyIfNeeded", NULL
23002 };
23003
23004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23006 if (SWIG_arg_fail(1)) SWIG_fail;
23007 if (obj1) {
23008 {
23009 arg2 = (bool)(SWIG_As_bool(obj1));
23010 if (SWIG_arg_fail(2)) SWIG_fail;
23011 }
23012 }
23013 {
23014 PyThreadState* __tstate = wxPyBeginAllowThreads();
23015 result = (bool)(arg1)->Yield(arg2);
23016
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 {
23021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23022 }
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj;
23031 wxPyApp *arg1 = (wxPyApp *) 0 ;
23032 PyObject * obj0 = 0 ;
23033 char *kwnames[] = {
23034 (char *) "self", NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23039 if (SWIG_arg_fail(1)) SWIG_fail;
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 (arg1)->WakeUpIdle();
23043
23044 wxPyEndAllowThreads(__tstate);
23045 if (PyErr_Occurred()) SWIG_fail;
23046 }
23047 Py_INCREF(Py_None); resultobj = Py_None;
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23055 PyObject *resultobj;
23056 bool result;
23057 char *kwnames[] = {
23058 NULL
23059 };
23060
23061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23062 {
23063 PyThreadState* __tstate = wxPyBeginAllowThreads();
23064 result = (bool)wxPyApp::IsMainLoopRunning();
23065
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 {
23070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23071 }
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23079 PyObject *resultobj;
23080 wxPyApp *arg1 = (wxPyApp *) 0 ;
23081 int result;
23082 PyObject * obj0 = 0 ;
23083 char *kwnames[] = {
23084 (char *) "self", NULL
23085 };
23086
23087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(1)) SWIG_fail;
23090 {
23091 PyThreadState* __tstate = wxPyBeginAllowThreads();
23092 result = (int)(arg1)->MainLoop();
23093
23094 wxPyEndAllowThreads(__tstate);
23095 if (PyErr_Occurred()) SWIG_fail;
23096 }
23097 {
23098 resultobj = SWIG_From_int((int)(result));
23099 }
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj;
23108 wxPyApp *arg1 = (wxPyApp *) 0 ;
23109 PyObject * obj0 = 0 ;
23110 char *kwnames[] = {
23111 (char *) "self", NULL
23112 };
23113
23114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23116 if (SWIG_arg_fail(1)) SWIG_fail;
23117 {
23118 PyThreadState* __tstate = wxPyBeginAllowThreads();
23119 (arg1)->Exit();
23120
23121 wxPyEndAllowThreads(__tstate);
23122 if (PyErr_Occurred()) SWIG_fail;
23123 }
23124 Py_INCREF(Py_None); resultobj = Py_None;
23125 return resultobj;
23126 fail:
23127 return NULL;
23128 }
23129
23130
23131 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23132 PyObject *resultobj;
23133 wxPyApp *arg1 = (wxPyApp *) 0 ;
23134 PyObject * obj0 = 0 ;
23135 char *kwnames[] = {
23136 (char *) "self", NULL
23137 };
23138
23139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23141 if (SWIG_arg_fail(1)) SWIG_fail;
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 (arg1)->ExitMainLoop();
23145
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 Py_INCREF(Py_None); resultobj = Py_None;
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23157 PyObject *resultobj;
23158 wxPyApp *arg1 = (wxPyApp *) 0 ;
23159 bool result;
23160 PyObject * obj0 = 0 ;
23161 char *kwnames[] = {
23162 (char *) "self", NULL
23163 };
23164
23165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23167 if (SWIG_arg_fail(1)) SWIG_fail;
23168 {
23169 PyThreadState* __tstate = wxPyBeginAllowThreads();
23170 result = (bool)(arg1)->Pending();
23171
23172 wxPyEndAllowThreads(__tstate);
23173 if (PyErr_Occurred()) SWIG_fail;
23174 }
23175 {
23176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23177 }
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj;
23186 wxPyApp *arg1 = (wxPyApp *) 0 ;
23187 bool result;
23188 PyObject * obj0 = 0 ;
23189 char *kwnames[] = {
23190 (char *) "self", NULL
23191 };
23192
23193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23195 if (SWIG_arg_fail(1)) SWIG_fail;
23196 {
23197 PyThreadState* __tstate = wxPyBeginAllowThreads();
23198 result = (bool)(arg1)->Dispatch();
23199
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 {
23204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23205 }
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23213 PyObject *resultobj;
23214 wxPyApp *arg1 = (wxPyApp *) 0 ;
23215 bool result;
23216 PyObject * obj0 = 0 ;
23217 char *kwnames[] = {
23218 (char *) "self", NULL
23219 };
23220
23221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23223 if (SWIG_arg_fail(1)) SWIG_fail;
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 result = (bool)(arg1)->ProcessIdle();
23227
23228 wxPyEndAllowThreads(__tstate);
23229 if (PyErr_Occurred()) SWIG_fail;
23230 }
23231 {
23232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23233 }
23234 return resultobj;
23235 fail:
23236 return NULL;
23237 }
23238
23239
23240 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23241 PyObject *resultobj;
23242 wxPyApp *arg1 = (wxPyApp *) 0 ;
23243 wxWindow *arg2 = (wxWindow *) 0 ;
23244 wxIdleEvent *arg3 = 0 ;
23245 bool result;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 PyObject * obj2 = 0 ;
23249 char *kwnames[] = {
23250 (char *) "self",(char *) "win",(char *) "event", NULL
23251 };
23252
23253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23255 if (SWIG_arg_fail(1)) SWIG_fail;
23256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23257 if (SWIG_arg_fail(2)) SWIG_fail;
23258 {
23259 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23260 if (SWIG_arg_fail(3)) SWIG_fail;
23261 if (arg3 == NULL) {
23262 SWIG_null_ref("wxIdleEvent");
23263 }
23264 if (SWIG_arg_fail(3)) SWIG_fail;
23265 }
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23269
23270 wxPyEndAllowThreads(__tstate);
23271 if (PyErr_Occurred()) SWIG_fail;
23272 }
23273 {
23274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23275 }
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23283 PyObject *resultobj;
23284 wxPyApp *arg1 = (wxPyApp *) 0 ;
23285 bool result;
23286 PyObject * obj0 = 0 ;
23287 char *kwnames[] = {
23288 (char *) "self", NULL
23289 };
23290
23291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23293 if (SWIG_arg_fail(1)) SWIG_fail;
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 result = (bool)((wxPyApp const *)arg1)->IsActive();
23297
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 {
23302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23303 }
23304 return resultobj;
23305 fail:
23306 return NULL;
23307 }
23308
23309
23310 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj;
23312 wxPyApp *arg1 = (wxPyApp *) 0 ;
23313 wxWindow *arg2 = (wxWindow *) 0 ;
23314 PyObject * obj0 = 0 ;
23315 PyObject * obj1 = 0 ;
23316 char *kwnames[] = {
23317 (char *) "self",(char *) "win", NULL
23318 };
23319
23320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23322 if (SWIG_arg_fail(1)) SWIG_fail;
23323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23324 if (SWIG_arg_fail(2)) SWIG_fail;
23325 {
23326 PyThreadState* __tstate = wxPyBeginAllowThreads();
23327 (arg1)->SetTopWindow(arg2);
23328
23329 wxPyEndAllowThreads(__tstate);
23330 if (PyErr_Occurred()) SWIG_fail;
23331 }
23332 Py_INCREF(Py_None); resultobj = Py_None;
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 wxPyApp *arg1 = (wxPyApp *) 0 ;
23342 wxWindow *result;
23343 PyObject * obj0 = 0 ;
23344 char *kwnames[] = {
23345 (char *) "self", NULL
23346 };
23347
23348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23350 if (SWIG_arg_fail(1)) SWIG_fail;
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23354
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 {
23359 resultobj = wxPyMake_wxObject(result, 0);
23360 }
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj;
23369 wxPyApp *arg1 = (wxPyApp *) 0 ;
23370 bool arg2 ;
23371 PyObject * obj0 = 0 ;
23372 PyObject * obj1 = 0 ;
23373 char *kwnames[] = {
23374 (char *) "self",(char *) "flag", NULL
23375 };
23376
23377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23379 if (SWIG_arg_fail(1)) SWIG_fail;
23380 {
23381 arg2 = (bool)(SWIG_As_bool(obj1));
23382 if (SWIG_arg_fail(2)) SWIG_fail;
23383 }
23384 {
23385 PyThreadState* __tstate = wxPyBeginAllowThreads();
23386 (arg1)->SetExitOnFrameDelete(arg2);
23387
23388 wxPyEndAllowThreads(__tstate);
23389 if (PyErr_Occurred()) SWIG_fail;
23390 }
23391 Py_INCREF(Py_None); resultobj = Py_None;
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23399 PyObject *resultobj;
23400 wxPyApp *arg1 = (wxPyApp *) 0 ;
23401 bool result;
23402 PyObject * obj0 = 0 ;
23403 char *kwnames[] = {
23404 (char *) "self", NULL
23405 };
23406
23407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23409 if (SWIG_arg_fail(1)) SWIG_fail;
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23413
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23419 }
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj;
23428 wxPyApp *arg1 = (wxPyApp *) 0 ;
23429 bool arg2 ;
23430 PyObject * obj0 = 0 ;
23431 PyObject * obj1 = 0 ;
23432 char *kwnames[] = {
23433 (char *) "self",(char *) "flag", NULL
23434 };
23435
23436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23438 if (SWIG_arg_fail(1)) SWIG_fail;
23439 {
23440 arg2 = (bool)(SWIG_As_bool(obj1));
23441 if (SWIG_arg_fail(2)) SWIG_fail;
23442 }
23443 {
23444 PyThreadState* __tstate = wxPyBeginAllowThreads();
23445 (arg1)->SetUseBestVisual(arg2);
23446
23447 wxPyEndAllowThreads(__tstate);
23448 if (PyErr_Occurred()) SWIG_fail;
23449 }
23450 Py_INCREF(Py_None); resultobj = Py_None;
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23458 PyObject *resultobj;
23459 wxPyApp *arg1 = (wxPyApp *) 0 ;
23460 bool result;
23461 PyObject * obj0 = 0 ;
23462 char *kwnames[] = {
23463 (char *) "self", NULL
23464 };
23465
23466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23468 if (SWIG_arg_fail(1)) SWIG_fail;
23469 {
23470 PyThreadState* __tstate = wxPyBeginAllowThreads();
23471 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23472
23473 wxPyEndAllowThreads(__tstate);
23474 if (PyErr_Occurred()) SWIG_fail;
23475 }
23476 {
23477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23478 }
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj;
23487 wxPyApp *arg1 = (wxPyApp *) 0 ;
23488 int arg2 ;
23489 PyObject * obj0 = 0 ;
23490 PyObject * obj1 = 0 ;
23491 char *kwnames[] = {
23492 (char *) "self",(char *) "mode", NULL
23493 };
23494
23495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23497 if (SWIG_arg_fail(1)) SWIG_fail;
23498 {
23499 arg2 = (int)(SWIG_As_int(obj1));
23500 if (SWIG_arg_fail(2)) SWIG_fail;
23501 }
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 (arg1)->SetPrintMode(arg2);
23505
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 Py_INCREF(Py_None); resultobj = Py_None;
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23517 PyObject *resultobj;
23518 wxPyApp *arg1 = (wxPyApp *) 0 ;
23519 int result;
23520 PyObject * obj0 = 0 ;
23521 char *kwnames[] = {
23522 (char *) "self", NULL
23523 };
23524
23525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23527 if (SWIG_arg_fail(1)) SWIG_fail;
23528 {
23529 PyThreadState* __tstate = wxPyBeginAllowThreads();
23530 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23531
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 {
23536 resultobj = SWIG_From_int((int)(result));
23537 }
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj;
23546 wxPyApp *arg1 = (wxPyApp *) 0 ;
23547 int arg2 ;
23548 PyObject * obj0 = 0 ;
23549 PyObject * obj1 = 0 ;
23550 char *kwnames[] = {
23551 (char *) "self",(char *) "mode", NULL
23552 };
23553
23554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23556 if (SWIG_arg_fail(1)) SWIG_fail;
23557 {
23558 arg2 = (int)(SWIG_As_int(obj1));
23559 if (SWIG_arg_fail(2)) SWIG_fail;
23560 }
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 (arg1)->SetAssertMode(arg2);
23564
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 Py_INCREF(Py_None); resultobj = Py_None;
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj;
23577 wxPyApp *arg1 = (wxPyApp *) 0 ;
23578 int result;
23579 PyObject * obj0 = 0 ;
23580 char *kwnames[] = {
23581 (char *) "self", NULL
23582 };
23583
23584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23586 if (SWIG_arg_fail(1)) SWIG_fail;
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (int)(arg1)->GetAssertMode();
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 {
23595 resultobj = SWIG_From_int((int)(result));
23596 }
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj;
23605 bool result;
23606 char *kwnames[] = {
23607 NULL
23608 };
23609
23610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23611 {
23612 PyThreadState* __tstate = wxPyBeginAllowThreads();
23613 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23614
23615 wxPyEndAllowThreads(__tstate);
23616 if (PyErr_Occurred()) SWIG_fail;
23617 }
23618 {
23619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23620 }
23621 return resultobj;
23622 fail:
23623 return NULL;
23624 }
23625
23626
23627 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23628 PyObject *resultobj;
23629 long result;
23630 char *kwnames[] = {
23631 NULL
23632 };
23633
23634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 result = (long)wxPyApp::GetMacAboutMenuItemId();
23638
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 resultobj = SWIG_From_long((long)(result));
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 long result;
23654 char *kwnames[] = {
23655 NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23662
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 {
23667 resultobj = SWIG_From_long((long)(result));
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj;
23677 long result;
23678 char *kwnames[] = {
23679 NULL
23680 };
23681
23682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (long)wxPyApp::GetMacExitMenuItemId();
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 {
23691 resultobj = SWIG_From_long((long)(result));
23692 }
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj;
23701 wxString result;
23702 char *kwnames[] = {
23703 NULL
23704 };
23705
23706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 result = wxPyApp::GetMacHelpMenuTitleName();
23710
23711 wxPyEndAllowThreads(__tstate);
23712 if (PyErr_Occurred()) SWIG_fail;
23713 }
23714 {
23715 #if wxUSE_UNICODE
23716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23717 #else
23718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23719 #endif
23720 }
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj;
23729 bool arg1 ;
23730 PyObject * obj0 = 0 ;
23731 char *kwnames[] = {
23732 (char *) "val", NULL
23733 };
23734
23735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23736 {
23737 arg1 = (bool)(SWIG_As_bool(obj0));
23738 if (SWIG_arg_fail(1)) SWIG_fail;
23739 }
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23743
23744 wxPyEndAllowThreads(__tstate);
23745 if (PyErr_Occurred()) SWIG_fail;
23746 }
23747 Py_INCREF(Py_None); resultobj = Py_None;
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23755 PyObject *resultobj;
23756 long arg1 ;
23757 PyObject * obj0 = 0 ;
23758 char *kwnames[] = {
23759 (char *) "val", NULL
23760 };
23761
23762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23763 {
23764 arg1 = (long)(SWIG_As_long(obj0));
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 }
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 wxPyApp::SetMacAboutMenuItemId(arg1);
23770
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 Py_INCREF(Py_None); resultobj = Py_None;
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23782 PyObject *resultobj;
23783 long arg1 ;
23784 PyObject * obj0 = 0 ;
23785 char *kwnames[] = {
23786 (char *) "val", NULL
23787 };
23788
23789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23790 {
23791 arg1 = (long)(SWIG_As_long(obj0));
23792 if (SWIG_arg_fail(1)) SWIG_fail;
23793 }
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23797
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 Py_INCREF(Py_None); resultobj = Py_None;
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23809 PyObject *resultobj;
23810 long arg1 ;
23811 PyObject * obj0 = 0 ;
23812 char *kwnames[] = {
23813 (char *) "val", NULL
23814 };
23815
23816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23817 {
23818 arg1 = (long)(SWIG_As_long(obj0));
23819 if (SWIG_arg_fail(1)) SWIG_fail;
23820 }
23821 {
23822 PyThreadState* __tstate = wxPyBeginAllowThreads();
23823 wxPyApp::SetMacExitMenuItemId(arg1);
23824
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 Py_INCREF(Py_None); resultobj = Py_None;
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23836 PyObject *resultobj;
23837 wxString *arg1 = 0 ;
23838 bool temp1 = false ;
23839 PyObject * obj0 = 0 ;
23840 char *kwnames[] = {
23841 (char *) "val", NULL
23842 };
23843
23844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23845 {
23846 arg1 = wxString_in_helper(obj0);
23847 if (arg1 == NULL) SWIG_fail;
23848 temp1 = true;
23849 }
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23853
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 Py_INCREF(Py_None); resultobj = Py_None;
23858 {
23859 if (temp1)
23860 delete arg1;
23861 }
23862 return resultobj;
23863 fail:
23864 {
23865 if (temp1)
23866 delete arg1;
23867 }
23868 return NULL;
23869 }
23870
23871
23872 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23873 PyObject *resultobj;
23874 wxPyApp *arg1 = (wxPyApp *) 0 ;
23875 PyObject * obj0 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "self", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23882 if (SWIG_arg_fail(1)) SWIG_fail;
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 (arg1)->_BootstrapApp();
23886
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 Py_INCREF(Py_None); resultobj = Py_None;
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23898 PyObject *resultobj;
23899 int result;
23900 char *kwnames[] = {
23901 NULL
23902 };
23903
23904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23905 {
23906 PyThreadState* __tstate = wxPyBeginAllowThreads();
23907 result = (int)PyApp_GetComCtl32Version();
23908
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 {
23913 resultobj = SWIG_From_int((int)(result));
23914 }
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23922 PyObject *obj;
23923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23924 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23925 Py_INCREF(obj);
23926 return Py_BuildValue((char *)"");
23927 }
23928 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23929 PyObject *resultobj;
23930 char *kwnames[] = {
23931 NULL
23932 };
23933
23934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23935 {
23936 PyThreadState* __tstate = wxPyBeginAllowThreads();
23937 wxExit();
23938
23939 wxPyEndAllowThreads(__tstate);
23940 if (PyErr_Occurred()) SWIG_fail;
23941 }
23942 Py_INCREF(Py_None); resultobj = Py_None;
23943 return resultobj;
23944 fail:
23945 return NULL;
23946 }
23947
23948
23949 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23950 PyObject *resultobj;
23951 bool result;
23952 char *kwnames[] = {
23953 NULL
23954 };
23955
23956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23957 {
23958 PyThreadState* __tstate = wxPyBeginAllowThreads();
23959 result = (bool)wxYield();
23960
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 {
23965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23966 }
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 bool result;
23976 char *kwnames[] = {
23977 NULL
23978 };
23979
23980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23981 {
23982 PyThreadState* __tstate = wxPyBeginAllowThreads();
23983 result = (bool)wxYieldIfNeeded();
23984
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 {
23989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23990 }
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23998 PyObject *resultobj;
23999 wxWindow *arg1 = (wxWindow *) NULL ;
24000 bool arg2 = (bool) false ;
24001 bool result;
24002 PyObject * obj0 = 0 ;
24003 PyObject * obj1 = 0 ;
24004 char *kwnames[] = {
24005 (char *) "win",(char *) "onlyIfNeeded", NULL
24006 };
24007
24008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24009 if (obj0) {
24010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24011 if (SWIG_arg_fail(1)) SWIG_fail;
24012 }
24013 if (obj1) {
24014 {
24015 arg2 = (bool)(SWIG_As_bool(obj1));
24016 if (SWIG_arg_fail(2)) SWIG_fail;
24017 }
24018 }
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (bool)wxSafeYield(arg1,arg2);
24022
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 {
24027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24028 }
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24036 PyObject *resultobj;
24037 char *kwnames[] = {
24038 NULL
24039 };
24040
24041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24042 {
24043 PyThreadState* __tstate = wxPyBeginAllowThreads();
24044 wxWakeUpIdle();
24045
24046 wxPyEndAllowThreads(__tstate);
24047 if (PyErr_Occurred()) SWIG_fail;
24048 }
24049 Py_INCREF(Py_None); resultobj = Py_None;
24050 return resultobj;
24051 fail:
24052 return NULL;
24053 }
24054
24055
24056 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24057 PyObject *resultobj;
24058 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24059 wxEvent *arg2 = 0 ;
24060 PyObject * obj0 = 0 ;
24061 PyObject * obj1 = 0 ;
24062 char *kwnames[] = {
24063 (char *) "dest",(char *) "event", NULL
24064 };
24065
24066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24068 if (SWIG_arg_fail(1)) SWIG_fail;
24069 {
24070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24071 if (SWIG_arg_fail(2)) SWIG_fail;
24072 if (arg2 == NULL) {
24073 SWIG_null_ref("wxEvent");
24074 }
24075 if (SWIG_arg_fail(2)) SWIG_fail;
24076 }
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 wxPostEvent(arg1,*arg2);
24080
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 Py_INCREF(Py_None); resultobj = Py_None;
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24092 PyObject *resultobj;
24093 char *kwnames[] = {
24094 NULL
24095 };
24096
24097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 wxApp_CleanUp();
24101
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 Py_INCREF(Py_None); resultobj = Py_None;
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj;
24114 wxPyApp *result;
24115 char *kwnames[] = {
24116 NULL
24117 };
24118
24119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 result = (wxPyApp *)wxPyGetApp();
24123
24124 wxPyEndAllowThreads(__tstate);
24125 if (PyErr_Occurred()) SWIG_fail;
24126 }
24127 {
24128 resultobj = wxPyMake_wxObject(result, 0);
24129 }
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj;
24138 char *arg1 = (char *) 0 ;
24139 PyObject * obj0 = 0 ;
24140 char *kwnames[] = {
24141 (char *) "encoding", NULL
24142 };
24143
24144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24145 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24146 SWIG_arg_fail(1);SWIG_fail;
24147 }
24148 {
24149 PyThreadState* __tstate = wxPyBeginAllowThreads();
24150 wxSetDefaultPyEncoding((char const *)arg1);
24151
24152 wxPyEndAllowThreads(__tstate);
24153 if (PyErr_Occurred()) SWIG_fail;
24154 }
24155 Py_INCREF(Py_None); resultobj = Py_None;
24156 return resultobj;
24157 fail:
24158 return NULL;
24159 }
24160
24161
24162 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24163 PyObject *resultobj;
24164 char *result;
24165 char *kwnames[] = {
24166 NULL
24167 };
24168
24169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 result = (char *)wxGetDefaultPyEncoding();
24173
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 resultobj = SWIG_FromCharPtr(result);
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj;
24186 wxEventLoop *result;
24187 char *kwnames[] = {
24188 NULL
24189 };
24190
24191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 result = (wxEventLoop *)new wxEventLoop();
24195
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24207 PyObject *resultobj;
24208 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24209 PyObject * obj0 = 0 ;
24210 char *kwnames[] = {
24211 (char *) "self", NULL
24212 };
24213
24214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24216 if (SWIG_arg_fail(1)) SWIG_fail;
24217 {
24218 PyThreadState* __tstate = wxPyBeginAllowThreads();
24219 delete arg1;
24220
24221 wxPyEndAllowThreads(__tstate);
24222 if (PyErr_Occurred()) SWIG_fail;
24223 }
24224 Py_INCREF(Py_None); resultobj = Py_None;
24225 return resultobj;
24226 fail:
24227 return NULL;
24228 }
24229
24230
24231 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj;
24233 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24234 int result;
24235 PyObject * obj0 = 0 ;
24236 char *kwnames[] = {
24237 (char *) "self", NULL
24238 };
24239
24240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24242 if (SWIG_arg_fail(1)) SWIG_fail;
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 result = (int)(arg1)->Run();
24246
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 {
24251 resultobj = SWIG_From_int((int)(result));
24252 }
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj;
24261 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24262 int arg2 = (int) 0 ;
24263 PyObject * obj0 = 0 ;
24264 PyObject * obj1 = 0 ;
24265 char *kwnames[] = {
24266 (char *) "self",(char *) "rc", NULL
24267 };
24268
24269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24271 if (SWIG_arg_fail(1)) SWIG_fail;
24272 if (obj1) {
24273 {
24274 arg2 = (int)(SWIG_As_int(obj1));
24275 if (SWIG_arg_fail(2)) SWIG_fail;
24276 }
24277 }
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 (arg1)->Exit(arg2);
24281
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 Py_INCREF(Py_None); resultobj = Py_None;
24286 return resultobj;
24287 fail:
24288 return NULL;
24289 }
24290
24291
24292 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24293 PyObject *resultobj;
24294 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24295 bool result;
24296 PyObject * obj0 = 0 ;
24297 char *kwnames[] = {
24298 (char *) "self", NULL
24299 };
24300
24301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24303 if (SWIG_arg_fail(1)) SWIG_fail;
24304 {
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 result = (bool)((wxEventLoop const *)arg1)->Pending();
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 {
24312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24313 }
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj;
24322 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24323 bool result;
24324 PyObject * obj0 = 0 ;
24325 char *kwnames[] = {
24326 (char *) "self", NULL
24327 };
24328
24329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24331 if (SWIG_arg_fail(1)) SWIG_fail;
24332 {
24333 PyThreadState* __tstate = wxPyBeginAllowThreads();
24334 result = (bool)(arg1)->Dispatch();
24335
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 {
24340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24341 }
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj;
24350 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24351 bool result;
24352 PyObject * obj0 = 0 ;
24353 char *kwnames[] = {
24354 (char *) "self", NULL
24355 };
24356
24357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24359 if (SWIG_arg_fail(1)) SWIG_fail;
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24363
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 {
24368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24369 }
24370 return resultobj;
24371 fail:
24372 return NULL;
24373 }
24374
24375
24376 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24377 PyObject *resultobj;
24378 wxEventLoop *result;
24379 char *kwnames[] = {
24380 NULL
24381 };
24382
24383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24384 {
24385 PyThreadState* __tstate = wxPyBeginAllowThreads();
24386 result = (wxEventLoop *)wxEventLoop::GetActive();
24387
24388 wxPyEndAllowThreads(__tstate);
24389 if (PyErr_Occurred()) SWIG_fail;
24390 }
24391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24392 return resultobj;
24393 fail:
24394 return NULL;
24395 }
24396
24397
24398 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24399 PyObject *resultobj;
24400 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24401 PyObject * obj0 = 0 ;
24402 char *kwnames[] = {
24403 (char *) "loop", NULL
24404 };
24405
24406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24408 if (SWIG_arg_fail(1)) SWIG_fail;
24409 {
24410 PyThreadState* __tstate = wxPyBeginAllowThreads();
24411 wxEventLoop::SetActive(arg1);
24412
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 Py_INCREF(Py_None); resultobj = Py_None;
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24424 PyObject *obj;
24425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24426 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24427 Py_INCREF(obj);
24428 return Py_BuildValue((char *)"");
24429 }
24430 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 int arg1 = (int) 0 ;
24433 int arg2 = (int) 0 ;
24434 int arg3 = (int) 0 ;
24435 wxAcceleratorEntry *result;
24436 PyObject * obj0 = 0 ;
24437 PyObject * obj1 = 0 ;
24438 PyObject * obj2 = 0 ;
24439 char *kwnames[] = {
24440 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24441 };
24442
24443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24444 if (obj0) {
24445 {
24446 arg1 = (int)(SWIG_As_int(obj0));
24447 if (SWIG_arg_fail(1)) SWIG_fail;
24448 }
24449 }
24450 if (obj1) {
24451 {
24452 arg2 = (int)(SWIG_As_int(obj1));
24453 if (SWIG_arg_fail(2)) SWIG_fail;
24454 }
24455 }
24456 if (obj2) {
24457 {
24458 arg3 = (int)(SWIG_As_int(obj2));
24459 if (SWIG_arg_fail(3)) SWIG_fail;
24460 }
24461 }
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24465
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj;
24478 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24479 PyObject * obj0 = 0 ;
24480 char *kwnames[] = {
24481 (char *) "self", NULL
24482 };
24483
24484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24486 if (SWIG_arg_fail(1)) SWIG_fail;
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 delete arg1;
24490
24491 wxPyEndAllowThreads(__tstate);
24492 if (PyErr_Occurred()) SWIG_fail;
24493 }
24494 Py_INCREF(Py_None); resultobj = Py_None;
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24502 PyObject *resultobj;
24503 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24504 int arg2 ;
24505 int arg3 ;
24506 int arg4 ;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 PyObject * obj2 = 0 ;
24510 PyObject * obj3 = 0 ;
24511 char *kwnames[] = {
24512 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24513 };
24514
24515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24517 if (SWIG_arg_fail(1)) SWIG_fail;
24518 {
24519 arg2 = (int)(SWIG_As_int(obj1));
24520 if (SWIG_arg_fail(2)) SWIG_fail;
24521 }
24522 {
24523 arg3 = (int)(SWIG_As_int(obj2));
24524 if (SWIG_arg_fail(3)) SWIG_fail;
24525 }
24526 {
24527 arg4 = (int)(SWIG_As_int(obj3));
24528 if (SWIG_arg_fail(4)) SWIG_fail;
24529 }
24530 {
24531 PyThreadState* __tstate = wxPyBeginAllowThreads();
24532 (arg1)->Set(arg2,arg3,arg4);
24533
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 Py_INCREF(Py_None); resultobj = Py_None;
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24545 PyObject *resultobj;
24546 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24547 int result;
24548 PyObject * obj0 = 0 ;
24549 char *kwnames[] = {
24550 (char *) "self", NULL
24551 };
24552
24553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24555 if (SWIG_arg_fail(1)) SWIG_fail;
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 result = (int)(arg1)->GetFlags();
24559
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 {
24564 resultobj = SWIG_From_int((int)(result));
24565 }
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24573 PyObject *resultobj;
24574 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24575 int result;
24576 PyObject * obj0 = 0 ;
24577 char *kwnames[] = {
24578 (char *) "self", NULL
24579 };
24580
24581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24583 if (SWIG_arg_fail(1)) SWIG_fail;
24584 {
24585 PyThreadState* __tstate = wxPyBeginAllowThreads();
24586 result = (int)(arg1)->GetKeyCode();
24587
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 {
24592 resultobj = SWIG_From_int((int)(result));
24593 }
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24601 PyObject *resultobj;
24602 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24603 int result;
24604 PyObject * obj0 = 0 ;
24605 char *kwnames[] = {
24606 (char *) "self", NULL
24607 };
24608
24609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24611 if (SWIG_arg_fail(1)) SWIG_fail;
24612 {
24613 PyThreadState* __tstate = wxPyBeginAllowThreads();
24614 result = (int)(arg1)->GetCommand();
24615
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 {
24620 resultobj = SWIG_From_int((int)(result));
24621 }
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24629 PyObject *obj;
24630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24631 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24632 Py_INCREF(obj);
24633 return Py_BuildValue((char *)"");
24634 }
24635 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24636 PyObject *resultobj;
24637 int arg1 ;
24638 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24639 wxAcceleratorTable *result;
24640 PyObject * obj0 = 0 ;
24641 char *kwnames[] = {
24642 (char *) "n", NULL
24643 };
24644
24645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24646 {
24647 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24648 if (arg2) arg1 = PyList_Size(obj0);
24649 else arg1 = 0;
24650 }
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24659 {
24660 delete [] arg2;
24661 }
24662 return resultobj;
24663 fail:
24664 {
24665 delete [] arg2;
24666 }
24667 return NULL;
24668 }
24669
24670
24671 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj;
24673 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24674 PyObject * obj0 = 0 ;
24675 char *kwnames[] = {
24676 (char *) "self", NULL
24677 };
24678
24679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24681 if (SWIG_arg_fail(1)) SWIG_fail;
24682 {
24683 PyThreadState* __tstate = wxPyBeginAllowThreads();
24684 delete arg1;
24685
24686 wxPyEndAllowThreads(__tstate);
24687 if (PyErr_Occurred()) SWIG_fail;
24688 }
24689 Py_INCREF(Py_None); resultobj = Py_None;
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24697 PyObject *resultobj;
24698 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24699 bool result;
24700 PyObject * obj0 = 0 ;
24701 char *kwnames[] = {
24702 (char *) "self", NULL
24703 };
24704
24705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24707 if (SWIG_arg_fail(1)) SWIG_fail;
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24711
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24725 PyObject *obj;
24726 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24727 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24728 Py_INCREF(obj);
24729 return Py_BuildValue((char *)"");
24730 }
24731 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24732 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24733 return 1;
24734 }
24735
24736
24737 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24738 PyObject *pyobj;
24739
24740 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24741 return pyobj;
24742 }
24743
24744
24745 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24746 PyObject *resultobj;
24747 wxString *arg1 = 0 ;
24748 wxAcceleratorEntry *result;
24749 bool temp1 = false ;
24750 PyObject * obj0 = 0 ;
24751 char *kwnames[] = {
24752 (char *) "label", NULL
24753 };
24754
24755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24756 {
24757 arg1 = wxString_in_helper(obj0);
24758 if (arg1 == NULL) SWIG_fail;
24759 temp1 = true;
24760 }
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24764
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24769 {
24770 if (temp1)
24771 delete arg1;
24772 }
24773 return resultobj;
24774 fail:
24775 {
24776 if (temp1)
24777 delete arg1;
24778 }
24779 return NULL;
24780 }
24781
24782
24783 static int _wrap_PanelNameStr_set(PyObject *) {
24784 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24785 return 1;
24786 }
24787
24788
24789 static PyObject *_wrap_PanelNameStr_get(void) {
24790 PyObject *pyobj;
24791
24792 {
24793 #if wxUSE_UNICODE
24794 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24795 #else
24796 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24797 #endif
24798 }
24799 return pyobj;
24800 }
24801
24802
24803 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxVisualAttributes *result;
24806 char *kwnames[] = {
24807 NULL
24808 };
24809
24810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24811 {
24812 PyThreadState* __tstate = wxPyBeginAllowThreads();
24813 result = (wxVisualAttributes *)new_wxVisualAttributes();
24814
24815 wxPyEndAllowThreads(__tstate);
24816 if (PyErr_Occurred()) SWIG_fail;
24817 }
24818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24819 return resultobj;
24820 fail:
24821 return NULL;
24822 }
24823
24824
24825 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24826 PyObject *resultobj;
24827 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24828 PyObject * obj0 = 0 ;
24829 char *kwnames[] = {
24830 (char *) "self", NULL
24831 };
24832
24833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24835 if (SWIG_arg_fail(1)) SWIG_fail;
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 delete_wxVisualAttributes(arg1);
24839
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 Py_INCREF(Py_None); resultobj = Py_None;
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24853 wxFont *arg2 = (wxFont *) 0 ;
24854 PyObject * obj0 = 0 ;
24855 PyObject * obj1 = 0 ;
24856 char *kwnames[] = {
24857 (char *) "self",(char *) "font", NULL
24858 };
24859
24860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(1)) SWIG_fail;
24863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24864 if (SWIG_arg_fail(2)) SWIG_fail;
24865 if (arg1) (arg1)->font = *arg2;
24866
24867 Py_INCREF(Py_None); resultobj = Py_None;
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24875 PyObject *resultobj;
24876 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24877 wxFont *result;
24878 PyObject * obj0 = 0 ;
24879 char *kwnames[] = {
24880 (char *) "self", NULL
24881 };
24882
24883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24885 if (SWIG_arg_fail(1)) SWIG_fail;
24886 result = (wxFont *)& ((arg1)->font);
24887
24888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24896 PyObject *resultobj;
24897 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24898 wxColour *arg2 = (wxColour *) 0 ;
24899 PyObject * obj0 = 0 ;
24900 PyObject * obj1 = 0 ;
24901 char *kwnames[] = {
24902 (char *) "self",(char *) "colFg", NULL
24903 };
24904
24905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24907 if (SWIG_arg_fail(1)) SWIG_fail;
24908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24909 if (SWIG_arg_fail(2)) SWIG_fail;
24910 if (arg1) (arg1)->colFg = *arg2;
24911
24912 Py_INCREF(Py_None); resultobj = Py_None;
24913 return resultobj;
24914 fail:
24915 return NULL;
24916 }
24917
24918
24919 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24920 PyObject *resultobj;
24921 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24922 wxColour *result;
24923 PyObject * obj0 = 0 ;
24924 char *kwnames[] = {
24925 (char *) "self", NULL
24926 };
24927
24928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24930 if (SWIG_arg_fail(1)) SWIG_fail;
24931 result = (wxColour *)& ((arg1)->colFg);
24932
24933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24941 PyObject *resultobj;
24942 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24943 wxColour *arg2 = (wxColour *) 0 ;
24944 PyObject * obj0 = 0 ;
24945 PyObject * obj1 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self",(char *) "colBg", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24954 if (SWIG_arg_fail(2)) SWIG_fail;
24955 if (arg1) (arg1)->colBg = *arg2;
24956
24957 Py_INCREF(Py_None); resultobj = Py_None;
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24965 PyObject *resultobj;
24966 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24967 wxColour *result;
24968 PyObject * obj0 = 0 ;
24969 char *kwnames[] = {
24970 (char *) "self", NULL
24971 };
24972
24973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24975 if (SWIG_arg_fail(1)) SWIG_fail;
24976 result = (wxColour *)& ((arg1)->colBg);
24977
24978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24979 return resultobj;
24980 fail:
24981 return NULL;
24982 }
24983
24984
24985 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24986 PyObject *obj;
24987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24988 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24989 Py_INCREF(obj);
24990 return Py_BuildValue((char *)"");
24991 }
24992 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24993 PyObject *resultobj;
24994 wxWindow *arg1 = (wxWindow *) 0 ;
24995 int arg2 = (int) (int)-1 ;
24996 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24997 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24998 wxSize const &arg4_defvalue = wxDefaultSize ;
24999 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25000 long arg5 = (long) 0 ;
25001 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25002 wxString *arg6 = (wxString *) &arg6_defvalue ;
25003 wxWindow *result;
25004 wxPoint temp3 ;
25005 wxSize temp4 ;
25006 bool temp6 = false ;
25007 PyObject * obj0 = 0 ;
25008 PyObject * obj1 = 0 ;
25009 PyObject * obj2 = 0 ;
25010 PyObject * obj3 = 0 ;
25011 PyObject * obj4 = 0 ;
25012 PyObject * obj5 = 0 ;
25013 char *kwnames[] = {
25014 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25015 };
25016
25017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25019 if (SWIG_arg_fail(1)) SWIG_fail;
25020 if (obj1) {
25021 {
25022 arg2 = (int const)(SWIG_As_int(obj1));
25023 if (SWIG_arg_fail(2)) SWIG_fail;
25024 }
25025 }
25026 if (obj2) {
25027 {
25028 arg3 = &temp3;
25029 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25030 }
25031 }
25032 if (obj3) {
25033 {
25034 arg4 = &temp4;
25035 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25036 }
25037 }
25038 if (obj4) {
25039 {
25040 arg5 = (long)(SWIG_As_long(obj4));
25041 if (SWIG_arg_fail(5)) SWIG_fail;
25042 }
25043 }
25044 if (obj5) {
25045 {
25046 arg6 = wxString_in_helper(obj5);
25047 if (arg6 == NULL) SWIG_fail;
25048 temp6 = true;
25049 }
25050 }
25051 {
25052 if (!wxPyCheckForApp()) SWIG_fail;
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25055
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25060 {
25061 if (temp6)
25062 delete arg6;
25063 }
25064 return resultobj;
25065 fail:
25066 {
25067 if (temp6)
25068 delete arg6;
25069 }
25070 return NULL;
25071 }
25072
25073
25074 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25075 PyObject *resultobj;
25076 wxWindow *result;
25077 char *kwnames[] = {
25078 NULL
25079 };
25080
25081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25082 {
25083 if (!wxPyCheckForApp()) SWIG_fail;
25084 PyThreadState* __tstate = wxPyBeginAllowThreads();
25085 result = (wxWindow *)new wxWindow();
25086
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj;
25099 wxWindow *arg1 = (wxWindow *) 0 ;
25100 wxWindow *arg2 = (wxWindow *) 0 ;
25101 int arg3 = (int) (int)-1 ;
25102 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25103 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25104 wxSize const &arg5_defvalue = wxDefaultSize ;
25105 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25106 long arg6 = (long) 0 ;
25107 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25108 wxString *arg7 = (wxString *) &arg7_defvalue ;
25109 bool result;
25110 wxPoint temp4 ;
25111 wxSize temp5 ;
25112 bool temp7 = false ;
25113 PyObject * obj0 = 0 ;
25114 PyObject * obj1 = 0 ;
25115 PyObject * obj2 = 0 ;
25116 PyObject * obj3 = 0 ;
25117 PyObject * obj4 = 0 ;
25118 PyObject * obj5 = 0 ;
25119 PyObject * obj6 = 0 ;
25120 char *kwnames[] = {
25121 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25122 };
25123
25124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25126 if (SWIG_arg_fail(1)) SWIG_fail;
25127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25128 if (SWIG_arg_fail(2)) SWIG_fail;
25129 if (obj2) {
25130 {
25131 arg3 = (int const)(SWIG_As_int(obj2));
25132 if (SWIG_arg_fail(3)) SWIG_fail;
25133 }
25134 }
25135 if (obj3) {
25136 {
25137 arg4 = &temp4;
25138 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25139 }
25140 }
25141 if (obj4) {
25142 {
25143 arg5 = &temp5;
25144 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25145 }
25146 }
25147 if (obj5) {
25148 {
25149 arg6 = (long)(SWIG_As_long(obj5));
25150 if (SWIG_arg_fail(6)) SWIG_fail;
25151 }
25152 }
25153 if (obj6) {
25154 {
25155 arg7 = wxString_in_helper(obj6);
25156 if (arg7 == NULL) SWIG_fail;
25157 temp7 = true;
25158 }
25159 }
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25163
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 {
25168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25169 }
25170 {
25171 if (temp7)
25172 delete arg7;
25173 }
25174 return resultobj;
25175 fail:
25176 {
25177 if (temp7)
25178 delete arg7;
25179 }
25180 return NULL;
25181 }
25182
25183
25184 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj;
25186 wxWindow *arg1 = (wxWindow *) 0 ;
25187 bool arg2 = (bool) false ;
25188 bool result;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 char *kwnames[] = {
25192 (char *) "self",(char *) "force", NULL
25193 };
25194
25195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25197 if (SWIG_arg_fail(1)) SWIG_fail;
25198 if (obj1) {
25199 {
25200 arg2 = (bool)(SWIG_As_bool(obj1));
25201 if (SWIG_arg_fail(2)) SWIG_fail;
25202 }
25203 }
25204 {
25205 PyThreadState* __tstate = wxPyBeginAllowThreads();
25206 result = (bool)(arg1)->Close(arg2);
25207
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 {
25212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25213 }
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25221 PyObject *resultobj;
25222 wxWindow *arg1 = (wxWindow *) 0 ;
25223 bool result;
25224 PyObject * obj0 = 0 ;
25225 char *kwnames[] = {
25226 (char *) "self", NULL
25227 };
25228
25229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25231 if (SWIG_arg_fail(1)) SWIG_fail;
25232 {
25233 PyThreadState* __tstate = wxPyBeginAllowThreads();
25234 result = (bool)(arg1)->Destroy();
25235
25236 wxPyEndAllowThreads(__tstate);
25237 if (PyErr_Occurred()) SWIG_fail;
25238 }
25239 {
25240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25241 }
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25249 PyObject *resultobj;
25250 wxWindow *arg1 = (wxWindow *) 0 ;
25251 bool result;
25252 PyObject * obj0 = 0 ;
25253 char *kwnames[] = {
25254 (char *) "self", NULL
25255 };
25256
25257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25259 if (SWIG_arg_fail(1)) SWIG_fail;
25260 {
25261 PyThreadState* __tstate = wxPyBeginAllowThreads();
25262 result = (bool)(arg1)->DestroyChildren();
25263
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 {
25268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25269 }
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25277 PyObject *resultobj;
25278 wxWindow *arg1 = (wxWindow *) 0 ;
25279 bool result;
25280 PyObject * obj0 = 0 ;
25281 char *kwnames[] = {
25282 (char *) "self", NULL
25283 };
25284
25285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25287 if (SWIG_arg_fail(1)) SWIG_fail;
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25291
25292 wxPyEndAllowThreads(__tstate);
25293 if (PyErr_Occurred()) SWIG_fail;
25294 }
25295 {
25296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25297 }
25298 return resultobj;
25299 fail:
25300 return NULL;
25301 }
25302
25303
25304 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25305 PyObject *resultobj;
25306 wxWindow *arg1 = (wxWindow *) 0 ;
25307 wxString *arg2 = 0 ;
25308 bool temp2 = false ;
25309 PyObject * obj0 = 0 ;
25310 PyObject * obj1 = 0 ;
25311 char *kwnames[] = {
25312 (char *) "self",(char *) "title", NULL
25313 };
25314
25315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25317 if (SWIG_arg_fail(1)) SWIG_fail;
25318 {
25319 arg2 = wxString_in_helper(obj1);
25320 if (arg2 == NULL) SWIG_fail;
25321 temp2 = true;
25322 }
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 (arg1)->SetTitle((wxString const &)*arg2);
25326
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 Py_INCREF(Py_None); resultobj = Py_None;
25331 {
25332 if (temp2)
25333 delete arg2;
25334 }
25335 return resultobj;
25336 fail:
25337 {
25338 if (temp2)
25339 delete arg2;
25340 }
25341 return NULL;
25342 }
25343
25344
25345 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj;
25347 wxWindow *arg1 = (wxWindow *) 0 ;
25348 wxString result;
25349 PyObject * obj0 = 0 ;
25350 char *kwnames[] = {
25351 (char *) "self", NULL
25352 };
25353
25354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25356 if (SWIG_arg_fail(1)) SWIG_fail;
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 result = ((wxWindow const *)arg1)->GetTitle();
25360
25361 wxPyEndAllowThreads(__tstate);
25362 if (PyErr_Occurred()) SWIG_fail;
25363 }
25364 {
25365 #if wxUSE_UNICODE
25366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25367 #else
25368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25369 #endif
25370 }
25371 return resultobj;
25372 fail:
25373 return NULL;
25374 }
25375
25376
25377 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25378 PyObject *resultobj;
25379 wxWindow *arg1 = (wxWindow *) 0 ;
25380 wxString *arg2 = 0 ;
25381 bool temp2 = false ;
25382 PyObject * obj0 = 0 ;
25383 PyObject * obj1 = 0 ;
25384 char *kwnames[] = {
25385 (char *) "self",(char *) "label", NULL
25386 };
25387
25388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25390 if (SWIG_arg_fail(1)) SWIG_fail;
25391 {
25392 arg2 = wxString_in_helper(obj1);
25393 if (arg2 == NULL) SWIG_fail;
25394 temp2 = true;
25395 }
25396 {
25397 PyThreadState* __tstate = wxPyBeginAllowThreads();
25398 (arg1)->SetLabel((wxString const &)*arg2);
25399
25400 wxPyEndAllowThreads(__tstate);
25401 if (PyErr_Occurred()) SWIG_fail;
25402 }
25403 Py_INCREF(Py_None); resultobj = Py_None;
25404 {
25405 if (temp2)
25406 delete arg2;
25407 }
25408 return resultobj;
25409 fail:
25410 {
25411 if (temp2)
25412 delete arg2;
25413 }
25414 return NULL;
25415 }
25416
25417
25418 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25419 PyObject *resultobj;
25420 wxWindow *arg1 = (wxWindow *) 0 ;
25421 wxString result;
25422 PyObject * obj0 = 0 ;
25423 char *kwnames[] = {
25424 (char *) "self", NULL
25425 };
25426
25427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25429 if (SWIG_arg_fail(1)) SWIG_fail;
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 result = ((wxWindow const *)arg1)->GetLabel();
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 {
25438 #if wxUSE_UNICODE
25439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25440 #else
25441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25442 #endif
25443 }
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj;
25452 wxWindow *arg1 = (wxWindow *) 0 ;
25453 wxString *arg2 = 0 ;
25454 bool temp2 = false ;
25455 PyObject * obj0 = 0 ;
25456 PyObject * obj1 = 0 ;
25457 char *kwnames[] = {
25458 (char *) "self",(char *) "name", NULL
25459 };
25460
25461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25463 if (SWIG_arg_fail(1)) SWIG_fail;
25464 {
25465 arg2 = wxString_in_helper(obj1);
25466 if (arg2 == NULL) SWIG_fail;
25467 temp2 = true;
25468 }
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 (arg1)->SetName((wxString const &)*arg2);
25472
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 Py_INCREF(Py_None); resultobj = Py_None;
25477 {
25478 if (temp2)
25479 delete arg2;
25480 }
25481 return resultobj;
25482 fail:
25483 {
25484 if (temp2)
25485 delete arg2;
25486 }
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 wxWindow *arg1 = (wxWindow *) 0 ;
25494 wxString result;
25495 PyObject * obj0 = 0 ;
25496 char *kwnames[] = {
25497 (char *) "self", NULL
25498 };
25499
25500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25502 if (SWIG_arg_fail(1)) SWIG_fail;
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 result = ((wxWindow const *)arg1)->GetName();
25506
25507 wxPyEndAllowThreads(__tstate);
25508 if (PyErr_Occurred()) SWIG_fail;
25509 }
25510 {
25511 #if wxUSE_UNICODE
25512 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25513 #else
25514 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25515 #endif
25516 }
25517 return resultobj;
25518 fail:
25519 return NULL;
25520 }
25521
25522
25523 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25524 PyObject *resultobj;
25525 wxWindow *arg1 = (wxWindow *) 0 ;
25526 wxWindowVariant arg2 ;
25527 PyObject * obj0 = 0 ;
25528 PyObject * obj1 = 0 ;
25529 char *kwnames[] = {
25530 (char *) "self",(char *) "variant", NULL
25531 };
25532
25533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25535 if (SWIG_arg_fail(1)) SWIG_fail;
25536 {
25537 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25538 if (SWIG_arg_fail(2)) SWIG_fail;
25539 }
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25543
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 Py_INCREF(Py_None); resultobj = Py_None;
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj;
25556 wxWindow *arg1 = (wxWindow *) 0 ;
25557 wxWindowVariant result;
25558 PyObject * obj0 = 0 ;
25559 char *kwnames[] = {
25560 (char *) "self", NULL
25561 };
25562
25563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25565 if (SWIG_arg_fail(1)) SWIG_fail;
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25569
25570 wxPyEndAllowThreads(__tstate);
25571 if (PyErr_Occurred()) SWIG_fail;
25572 }
25573 resultobj = SWIG_From_int((result));
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25581 PyObject *resultobj;
25582 wxWindow *arg1 = (wxWindow *) 0 ;
25583 int arg2 ;
25584 PyObject * obj0 = 0 ;
25585 PyObject * obj1 = 0 ;
25586 char *kwnames[] = {
25587 (char *) "self",(char *) "winid", NULL
25588 };
25589
25590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25592 if (SWIG_arg_fail(1)) SWIG_fail;
25593 {
25594 arg2 = (int)(SWIG_As_int(obj1));
25595 if (SWIG_arg_fail(2)) SWIG_fail;
25596 }
25597 {
25598 PyThreadState* __tstate = wxPyBeginAllowThreads();
25599 (arg1)->SetId(arg2);
25600
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 Py_INCREF(Py_None); resultobj = Py_None;
25605 return resultobj;
25606 fail:
25607 return NULL;
25608 }
25609
25610
25611 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25612 PyObject *resultobj;
25613 wxWindow *arg1 = (wxWindow *) 0 ;
25614 int result;
25615 PyObject * obj0 = 0 ;
25616 char *kwnames[] = {
25617 (char *) "self", NULL
25618 };
25619
25620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25622 if (SWIG_arg_fail(1)) SWIG_fail;
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 result = (int)((wxWindow const *)arg1)->GetId();
25626
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 {
25631 resultobj = SWIG_From_int((int)(result));
25632 }
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj;
25641 int result;
25642 char *kwnames[] = {
25643 NULL
25644 };
25645
25646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25647 {
25648 PyThreadState* __tstate = wxPyBeginAllowThreads();
25649 result = (int)wxWindow::NewControlId();
25650
25651 wxPyEndAllowThreads(__tstate);
25652 if (PyErr_Occurred()) SWIG_fail;
25653 }
25654 {
25655 resultobj = SWIG_From_int((int)(result));
25656 }
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj;
25665 int arg1 ;
25666 int result;
25667 PyObject * obj0 = 0 ;
25668 char *kwnames[] = {
25669 (char *) "winid", NULL
25670 };
25671
25672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25673 {
25674 arg1 = (int)(SWIG_As_int(obj0));
25675 if (SWIG_arg_fail(1)) SWIG_fail;
25676 }
25677 {
25678 PyThreadState* __tstate = wxPyBeginAllowThreads();
25679 result = (int)wxWindow::NextControlId(arg1);
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 {
25685 resultobj = SWIG_From_int((int)(result));
25686 }
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25694 PyObject *resultobj;
25695 int arg1 ;
25696 int result;
25697 PyObject * obj0 = 0 ;
25698 char *kwnames[] = {
25699 (char *) "winid", NULL
25700 };
25701
25702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25703 {
25704 arg1 = (int)(SWIG_As_int(obj0));
25705 if (SWIG_arg_fail(1)) SWIG_fail;
25706 }
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = (int)wxWindow::PrevControlId(arg1);
25710
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 {
25715 resultobj = SWIG_From_int((int)(result));
25716 }
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj;
25725 wxWindow *arg1 = (wxWindow *) 0 ;
25726 wxSize *arg2 = 0 ;
25727 wxSize temp2 ;
25728 PyObject * obj0 = 0 ;
25729 PyObject * obj1 = 0 ;
25730 char *kwnames[] = {
25731 (char *) "self",(char *) "size", NULL
25732 };
25733
25734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25736 if (SWIG_arg_fail(1)) SWIG_fail;
25737 {
25738 arg2 = &temp2;
25739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25740 }
25741 {
25742 PyThreadState* __tstate = wxPyBeginAllowThreads();
25743 (arg1)->SetSize((wxSize const &)*arg2);
25744
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 Py_INCREF(Py_None); resultobj = Py_None;
25749 return resultobj;
25750 fail:
25751 return NULL;
25752 }
25753
25754
25755 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj;
25757 wxWindow *arg1 = (wxWindow *) 0 ;
25758 int arg2 ;
25759 int arg3 ;
25760 int arg4 ;
25761 int arg5 ;
25762 int arg6 = (int) wxSIZE_AUTO ;
25763 PyObject * obj0 = 0 ;
25764 PyObject * obj1 = 0 ;
25765 PyObject * obj2 = 0 ;
25766 PyObject * obj3 = 0 ;
25767 PyObject * obj4 = 0 ;
25768 PyObject * obj5 = 0 ;
25769 char *kwnames[] = {
25770 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25771 };
25772
25773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25775 if (SWIG_arg_fail(1)) SWIG_fail;
25776 {
25777 arg2 = (int)(SWIG_As_int(obj1));
25778 if (SWIG_arg_fail(2)) SWIG_fail;
25779 }
25780 {
25781 arg3 = (int)(SWIG_As_int(obj2));
25782 if (SWIG_arg_fail(3)) SWIG_fail;
25783 }
25784 {
25785 arg4 = (int)(SWIG_As_int(obj3));
25786 if (SWIG_arg_fail(4)) SWIG_fail;
25787 }
25788 {
25789 arg5 = (int)(SWIG_As_int(obj4));
25790 if (SWIG_arg_fail(5)) SWIG_fail;
25791 }
25792 if (obj5) {
25793 {
25794 arg6 = (int)(SWIG_As_int(obj5));
25795 if (SWIG_arg_fail(6)) SWIG_fail;
25796 }
25797 }
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25801
25802 wxPyEndAllowThreads(__tstate);
25803 if (PyErr_Occurred()) SWIG_fail;
25804 }
25805 Py_INCREF(Py_None); resultobj = Py_None;
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj;
25814 wxWindow *arg1 = (wxWindow *) 0 ;
25815 wxRect *arg2 = 0 ;
25816 int arg3 = (int) wxSIZE_AUTO ;
25817 wxRect temp2 ;
25818 PyObject * obj0 = 0 ;
25819 PyObject * obj1 = 0 ;
25820 PyObject * obj2 = 0 ;
25821 char *kwnames[] = {
25822 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25823 };
25824
25825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25827 if (SWIG_arg_fail(1)) SWIG_fail;
25828 {
25829 arg2 = &temp2;
25830 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25831 }
25832 if (obj2) {
25833 {
25834 arg3 = (int)(SWIG_As_int(obj2));
25835 if (SWIG_arg_fail(3)) SWIG_fail;
25836 }
25837 }
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25841
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 Py_INCREF(Py_None); resultobj = Py_None;
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25853 PyObject *resultobj;
25854 wxWindow *arg1 = (wxWindow *) 0 ;
25855 int arg2 ;
25856 int arg3 ;
25857 PyObject * obj0 = 0 ;
25858 PyObject * obj1 = 0 ;
25859 PyObject * obj2 = 0 ;
25860 char *kwnames[] = {
25861 (char *) "self",(char *) "width",(char *) "height", NULL
25862 };
25863
25864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25866 if (SWIG_arg_fail(1)) SWIG_fail;
25867 {
25868 arg2 = (int)(SWIG_As_int(obj1));
25869 if (SWIG_arg_fail(2)) SWIG_fail;
25870 }
25871 {
25872 arg3 = (int)(SWIG_As_int(obj2));
25873 if (SWIG_arg_fail(3)) SWIG_fail;
25874 }
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 (arg1)->SetSize(arg2,arg3);
25878
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 Py_INCREF(Py_None); resultobj = Py_None;
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25890 PyObject *resultobj;
25891 wxWindow *arg1 = (wxWindow *) 0 ;
25892 wxPoint *arg2 = 0 ;
25893 int arg3 = (int) wxSIZE_USE_EXISTING ;
25894 wxPoint temp2 ;
25895 PyObject * obj0 = 0 ;
25896 PyObject * obj1 = 0 ;
25897 PyObject * obj2 = 0 ;
25898 char *kwnames[] = {
25899 (char *) "self",(char *) "pt",(char *) "flags", NULL
25900 };
25901
25902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25904 if (SWIG_arg_fail(1)) SWIG_fail;
25905 {
25906 arg2 = &temp2;
25907 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25908 }
25909 if (obj2) {
25910 {
25911 arg3 = (int)(SWIG_As_int(obj2));
25912 if (SWIG_arg_fail(3)) SWIG_fail;
25913 }
25914 }
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 (arg1)->Move((wxPoint const &)*arg2,arg3);
25918
25919 wxPyEndAllowThreads(__tstate);
25920 if (PyErr_Occurred()) SWIG_fail;
25921 }
25922 Py_INCREF(Py_None); resultobj = Py_None;
25923 return resultobj;
25924 fail:
25925 return NULL;
25926 }
25927
25928
25929 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25930 PyObject *resultobj;
25931 wxWindow *arg1 = (wxWindow *) 0 ;
25932 int arg2 ;
25933 int arg3 ;
25934 int arg4 = (int) wxSIZE_USE_EXISTING ;
25935 PyObject * obj0 = 0 ;
25936 PyObject * obj1 = 0 ;
25937 PyObject * obj2 = 0 ;
25938 PyObject * obj3 = 0 ;
25939 char *kwnames[] = {
25940 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25941 };
25942
25943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25945 if (SWIG_arg_fail(1)) SWIG_fail;
25946 {
25947 arg2 = (int)(SWIG_As_int(obj1));
25948 if (SWIG_arg_fail(2)) SWIG_fail;
25949 }
25950 {
25951 arg3 = (int)(SWIG_As_int(obj2));
25952 if (SWIG_arg_fail(3)) SWIG_fail;
25953 }
25954 if (obj3) {
25955 {
25956 arg4 = (int)(SWIG_As_int(obj3));
25957 if (SWIG_arg_fail(4)) SWIG_fail;
25958 }
25959 }
25960 {
25961 PyThreadState* __tstate = wxPyBeginAllowThreads();
25962 (arg1)->Move(arg2,arg3,arg4);
25963
25964 wxPyEndAllowThreads(__tstate);
25965 if (PyErr_Occurred()) SWIG_fail;
25966 }
25967 Py_INCREF(Py_None); resultobj = Py_None;
25968 return resultobj;
25969 fail:
25970 return NULL;
25971 }
25972
25973
25974 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25975 PyObject *resultobj;
25976 wxWindow *arg1 = (wxWindow *) 0 ;
25977 wxSize const &arg2_defvalue = wxDefaultSize ;
25978 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25979 wxSize temp2 ;
25980 PyObject * obj0 = 0 ;
25981 PyObject * obj1 = 0 ;
25982 char *kwnames[] = {
25983 (char *) "self",(char *) "size", NULL
25984 };
25985
25986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25988 if (SWIG_arg_fail(1)) SWIG_fail;
25989 if (obj1) {
25990 {
25991 arg2 = &temp2;
25992 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25993 }
25994 }
25995 {
25996 PyThreadState* __tstate = wxPyBeginAllowThreads();
25997 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25998
25999 wxPyEndAllowThreads(__tstate);
26000 if (PyErr_Occurred()) SWIG_fail;
26001 }
26002 Py_INCREF(Py_None); resultobj = Py_None;
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj;
26011 wxWindow *arg1 = (wxWindow *) 0 ;
26012 PyObject * obj0 = 0 ;
26013 char *kwnames[] = {
26014 (char *) "self", NULL
26015 };
26016
26017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26019 if (SWIG_arg_fail(1)) SWIG_fail;
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 (arg1)->Raise();
26023
26024 wxPyEndAllowThreads(__tstate);
26025 if (PyErr_Occurred()) SWIG_fail;
26026 }
26027 Py_INCREF(Py_None); resultobj = Py_None;
26028 return resultobj;
26029 fail:
26030 return NULL;
26031 }
26032
26033
26034 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26035 PyObject *resultobj;
26036 wxWindow *arg1 = (wxWindow *) 0 ;
26037 PyObject * obj0 = 0 ;
26038 char *kwnames[] = {
26039 (char *) "self", NULL
26040 };
26041
26042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26044 if (SWIG_arg_fail(1)) SWIG_fail;
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 (arg1)->Lower();
26048
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 Py_INCREF(Py_None); resultobj = Py_None;
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26060 PyObject *resultobj;
26061 wxWindow *arg1 = (wxWindow *) 0 ;
26062 wxSize *arg2 = 0 ;
26063 wxSize temp2 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 char *kwnames[] = {
26067 (char *) "self",(char *) "size", NULL
26068 };
26069
26070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26072 if (SWIG_arg_fail(1)) SWIG_fail;
26073 {
26074 arg2 = &temp2;
26075 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26076 }
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 (arg1)->SetClientSize((wxSize const &)*arg2);
26080
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 Py_INCREF(Py_None); resultobj = Py_None;
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj;
26093 wxWindow *arg1 = (wxWindow *) 0 ;
26094 int arg2 ;
26095 int arg3 ;
26096 PyObject * obj0 = 0 ;
26097 PyObject * obj1 = 0 ;
26098 PyObject * obj2 = 0 ;
26099 char *kwnames[] = {
26100 (char *) "self",(char *) "width",(char *) "height", NULL
26101 };
26102
26103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26105 if (SWIG_arg_fail(1)) SWIG_fail;
26106 {
26107 arg2 = (int)(SWIG_As_int(obj1));
26108 if (SWIG_arg_fail(2)) SWIG_fail;
26109 }
26110 {
26111 arg3 = (int)(SWIG_As_int(obj2));
26112 if (SWIG_arg_fail(3)) SWIG_fail;
26113 }
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 (arg1)->SetClientSize(arg2,arg3);
26117
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 Py_INCREF(Py_None); resultobj = Py_None;
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj;
26130 wxWindow *arg1 = (wxWindow *) 0 ;
26131 wxRect *arg2 = 0 ;
26132 wxRect temp2 ;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char *kwnames[] = {
26136 (char *) "self",(char *) "rect", NULL
26137 };
26138
26139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26141 if (SWIG_arg_fail(1)) SWIG_fail;
26142 {
26143 arg2 = &temp2;
26144 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26145 }
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 (arg1)->SetClientSize((wxRect const &)*arg2);
26149
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 Py_INCREF(Py_None); resultobj = Py_None;
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj;
26162 wxWindow *arg1 = (wxWindow *) 0 ;
26163 wxPoint result;
26164 PyObject * obj0 = 0 ;
26165 char *kwnames[] = {
26166 (char *) "self", NULL
26167 };
26168
26169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26171 if (SWIG_arg_fail(1)) SWIG_fail;
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 result = (arg1)->GetPosition();
26175
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 {
26180 wxPoint * resultptr;
26181 resultptr = new wxPoint((wxPoint &)(result));
26182 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26183 }
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26191 PyObject *resultobj;
26192 wxWindow *arg1 = (wxWindow *) 0 ;
26193 int *arg2 = (int *) 0 ;
26194 int *arg3 = (int *) 0 ;
26195 int temp2 ;
26196 int res2 = 0 ;
26197 int temp3 ;
26198 int res3 = 0 ;
26199 PyObject * obj0 = 0 ;
26200 char *kwnames[] = {
26201 (char *) "self", NULL
26202 };
26203
26204 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26205 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26208 if (SWIG_arg_fail(1)) SWIG_fail;
26209 {
26210 PyThreadState* __tstate = wxPyBeginAllowThreads();
26211 (arg1)->GetPosition(arg2,arg3);
26212
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 Py_INCREF(Py_None); resultobj = Py_None;
26217 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26218 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26219 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26220 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj;
26229 wxWindow *arg1 = (wxWindow *) 0 ;
26230 wxSize result;
26231 PyObject * obj0 = 0 ;
26232 char *kwnames[] = {
26233 (char *) "self", NULL
26234 };
26235
26236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26238 if (SWIG_arg_fail(1)) SWIG_fail;
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = ((wxWindow const *)arg1)->GetSize();
26242
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 {
26247 wxSize * resultptr;
26248 resultptr = new wxSize((wxSize &)(result));
26249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26250 }
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26258 PyObject *resultobj;
26259 wxWindow *arg1 = (wxWindow *) 0 ;
26260 int *arg2 = (int *) 0 ;
26261 int *arg3 = (int *) 0 ;
26262 int temp2 ;
26263 int res2 = 0 ;
26264 int temp3 ;
26265 int res3 = 0 ;
26266 PyObject * obj0 = 0 ;
26267 char *kwnames[] = {
26268 (char *) "self", NULL
26269 };
26270
26271 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26272 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26275 if (SWIG_arg_fail(1)) SWIG_fail;
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26279
26280 wxPyEndAllowThreads(__tstate);
26281 if (PyErr_Occurred()) SWIG_fail;
26282 }
26283 Py_INCREF(Py_None); resultobj = Py_None;
26284 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26285 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26286 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26287 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26288 return resultobj;
26289 fail:
26290 return NULL;
26291 }
26292
26293
26294 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26295 PyObject *resultobj;
26296 wxWindow *arg1 = (wxWindow *) 0 ;
26297 wxRect result;
26298 PyObject * obj0 = 0 ;
26299 char *kwnames[] = {
26300 (char *) "self", NULL
26301 };
26302
26303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26305 if (SWIG_arg_fail(1)) SWIG_fail;
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = ((wxWindow const *)arg1)->GetRect();
26309
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 {
26314 wxRect * resultptr;
26315 resultptr = new wxRect((wxRect &)(result));
26316 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26317 }
26318 return resultobj;
26319 fail:
26320 return NULL;
26321 }
26322
26323
26324 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26325 PyObject *resultobj;
26326 wxWindow *arg1 = (wxWindow *) 0 ;
26327 wxSize result;
26328 PyObject * obj0 = 0 ;
26329 char *kwnames[] = {
26330 (char *) "self", NULL
26331 };
26332
26333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26335 if (SWIG_arg_fail(1)) SWIG_fail;
26336 {
26337 PyThreadState* __tstate = wxPyBeginAllowThreads();
26338 result = ((wxWindow const *)arg1)->GetClientSize();
26339
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 {
26344 wxSize * resultptr;
26345 resultptr = new wxSize((wxSize &)(result));
26346 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26347 }
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26355 PyObject *resultobj;
26356 wxWindow *arg1 = (wxWindow *) 0 ;
26357 int *arg2 = (int *) 0 ;
26358 int *arg3 = (int *) 0 ;
26359 int temp2 ;
26360 int res2 = 0 ;
26361 int temp3 ;
26362 int res3 = 0 ;
26363 PyObject * obj0 = 0 ;
26364 char *kwnames[] = {
26365 (char *) "self", NULL
26366 };
26367
26368 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26369 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26372 if (SWIG_arg_fail(1)) SWIG_fail;
26373 {
26374 PyThreadState* __tstate = wxPyBeginAllowThreads();
26375 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26376
26377 wxPyEndAllowThreads(__tstate);
26378 if (PyErr_Occurred()) SWIG_fail;
26379 }
26380 Py_INCREF(Py_None); resultobj = Py_None;
26381 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26382 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26383 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26384 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26392 PyObject *resultobj;
26393 wxWindow *arg1 = (wxWindow *) 0 ;
26394 wxPoint result;
26395 PyObject * obj0 = 0 ;
26396 char *kwnames[] = {
26397 (char *) "self", NULL
26398 };
26399
26400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26402 if (SWIG_arg_fail(1)) SWIG_fail;
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26406
26407 wxPyEndAllowThreads(__tstate);
26408 if (PyErr_Occurred()) SWIG_fail;
26409 }
26410 {
26411 wxPoint * resultptr;
26412 resultptr = new wxPoint((wxPoint &)(result));
26413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26422 PyObject *resultobj;
26423 wxWindow *arg1 = (wxWindow *) 0 ;
26424 wxRect result;
26425 PyObject * obj0 = 0 ;
26426 char *kwnames[] = {
26427 (char *) "self", NULL
26428 };
26429
26430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26432 if (SWIG_arg_fail(1)) SWIG_fail;
26433 {
26434 PyThreadState* __tstate = wxPyBeginAllowThreads();
26435 result = ((wxWindow const *)arg1)->GetClientRect();
26436
26437 wxPyEndAllowThreads(__tstate);
26438 if (PyErr_Occurred()) SWIG_fail;
26439 }
26440 {
26441 wxRect * resultptr;
26442 resultptr = new wxRect((wxRect &)(result));
26443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26444 }
26445 return resultobj;
26446 fail:
26447 return NULL;
26448 }
26449
26450
26451 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26452 PyObject *resultobj;
26453 wxWindow *arg1 = (wxWindow *) 0 ;
26454 wxSize result;
26455 PyObject * obj0 = 0 ;
26456 char *kwnames[] = {
26457 (char *) "self", NULL
26458 };
26459
26460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26462 if (SWIG_arg_fail(1)) SWIG_fail;
26463 {
26464 PyThreadState* __tstate = wxPyBeginAllowThreads();
26465 result = ((wxWindow const *)arg1)->GetBestSize();
26466
26467 wxPyEndAllowThreads(__tstate);
26468 if (PyErr_Occurred()) SWIG_fail;
26469 }
26470 {
26471 wxSize * resultptr;
26472 resultptr = new wxSize((wxSize &)(result));
26473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26474 }
26475 return resultobj;
26476 fail:
26477 return NULL;
26478 }
26479
26480
26481 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26482 PyObject *resultobj;
26483 wxWindow *arg1 = (wxWindow *) 0 ;
26484 int *arg2 = (int *) 0 ;
26485 int *arg3 = (int *) 0 ;
26486 int temp2 ;
26487 int res2 = 0 ;
26488 int temp3 ;
26489 int res3 = 0 ;
26490 PyObject * obj0 = 0 ;
26491 char *kwnames[] = {
26492 (char *) "self", NULL
26493 };
26494
26495 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26496 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26499 if (SWIG_arg_fail(1)) SWIG_fail;
26500 {
26501 PyThreadState* __tstate = wxPyBeginAllowThreads();
26502 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26503
26504 wxPyEndAllowThreads(__tstate);
26505 if (PyErr_Occurred()) SWIG_fail;
26506 }
26507 Py_INCREF(Py_None); resultobj = Py_None;
26508 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26509 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26510 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26511 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26512 return resultobj;
26513 fail:
26514 return NULL;
26515 }
26516
26517
26518 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26519 PyObject *resultobj;
26520 wxWindow *arg1 = (wxWindow *) 0 ;
26521 PyObject * obj0 = 0 ;
26522 char *kwnames[] = {
26523 (char *) "self", NULL
26524 };
26525
26526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26528 if (SWIG_arg_fail(1)) SWIG_fail;
26529 {
26530 PyThreadState* __tstate = wxPyBeginAllowThreads();
26531 (arg1)->InvalidateBestSize();
26532
26533 wxPyEndAllowThreads(__tstate);
26534 if (PyErr_Occurred()) SWIG_fail;
26535 }
26536 Py_INCREF(Py_None); resultobj = Py_None;
26537 return resultobj;
26538 fail:
26539 return NULL;
26540 }
26541
26542
26543 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26544 PyObject *resultobj;
26545 wxWindow *arg1 = (wxWindow *) 0 ;
26546 wxSize result;
26547 PyObject * obj0 = 0 ;
26548 char *kwnames[] = {
26549 (char *) "self", NULL
26550 };
26551
26552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26554 if (SWIG_arg_fail(1)) SWIG_fail;
26555 {
26556 PyThreadState* __tstate = wxPyBeginAllowThreads();
26557 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26558
26559 wxPyEndAllowThreads(__tstate);
26560 if (PyErr_Occurred()) SWIG_fail;
26561 }
26562 {
26563 wxSize * resultptr;
26564 resultptr = new wxSize((wxSize &)(result));
26565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26566 }
26567 return resultobj;
26568 fail:
26569 return NULL;
26570 }
26571
26572
26573 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj;
26575 wxWindow *arg1 = (wxWindow *) 0 ;
26576 wxSize result;
26577 PyObject * obj0 = 0 ;
26578 char *kwnames[] = {
26579 (char *) "self", NULL
26580 };
26581
26582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26584 if (SWIG_arg_fail(1)) SWIG_fail;
26585 {
26586 PyThreadState* __tstate = wxPyBeginAllowThreads();
26587 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26588
26589 wxPyEndAllowThreads(__tstate);
26590 if (PyErr_Occurred()) SWIG_fail;
26591 }
26592 {
26593 wxSize * resultptr;
26594 resultptr = new wxSize((wxSize &)(result));
26595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26596 }
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26604 PyObject *resultobj;
26605 wxWindow *arg1 = (wxWindow *) 0 ;
26606 int arg2 = (int) wxBOTH ;
26607 PyObject * obj0 = 0 ;
26608 PyObject * obj1 = 0 ;
26609 char *kwnames[] = {
26610 (char *) "self",(char *) "direction", NULL
26611 };
26612
26613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26615 if (SWIG_arg_fail(1)) SWIG_fail;
26616 if (obj1) {
26617 {
26618 arg2 = (int)(SWIG_As_int(obj1));
26619 if (SWIG_arg_fail(2)) SWIG_fail;
26620 }
26621 }
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 (arg1)->Center(arg2);
26625
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 Py_INCREF(Py_None); resultobj = Py_None;
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj;
26638 wxWindow *arg1 = (wxWindow *) 0 ;
26639 int arg2 = (int) wxBOTH ;
26640 PyObject * obj0 = 0 ;
26641 PyObject * obj1 = 0 ;
26642 char *kwnames[] = {
26643 (char *) "self",(char *) "dir", NULL
26644 };
26645
26646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26648 if (SWIG_arg_fail(1)) SWIG_fail;
26649 if (obj1) {
26650 {
26651 arg2 = (int)(SWIG_As_int(obj1));
26652 if (SWIG_arg_fail(2)) SWIG_fail;
26653 }
26654 }
26655 {
26656 PyThreadState* __tstate = wxPyBeginAllowThreads();
26657 (arg1)->CenterOnScreen(arg2);
26658
26659 wxPyEndAllowThreads(__tstate);
26660 if (PyErr_Occurred()) SWIG_fail;
26661 }
26662 Py_INCREF(Py_None); resultobj = Py_None;
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26670 PyObject *resultobj;
26671 wxWindow *arg1 = (wxWindow *) 0 ;
26672 int arg2 = (int) wxBOTH ;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 char *kwnames[] = {
26676 (char *) "self",(char *) "dir", NULL
26677 };
26678
26679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26681 if (SWIG_arg_fail(1)) SWIG_fail;
26682 if (obj1) {
26683 {
26684 arg2 = (int)(SWIG_As_int(obj1));
26685 if (SWIG_arg_fail(2)) SWIG_fail;
26686 }
26687 }
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 (arg1)->CenterOnParent(arg2);
26691
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 Py_INCREF(Py_None); resultobj = Py_None;
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26703 PyObject *resultobj;
26704 wxWindow *arg1 = (wxWindow *) 0 ;
26705 PyObject * obj0 = 0 ;
26706 char *kwnames[] = {
26707 (char *) "self", NULL
26708 };
26709
26710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26712 if (SWIG_arg_fail(1)) SWIG_fail;
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 (arg1)->Fit();
26716
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 Py_INCREF(Py_None); resultobj = Py_None;
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26728 PyObject *resultobj;
26729 wxWindow *arg1 = (wxWindow *) 0 ;
26730 PyObject * obj0 = 0 ;
26731 char *kwnames[] = {
26732 (char *) "self", NULL
26733 };
26734
26735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26737 if (SWIG_arg_fail(1)) SWIG_fail;
26738 {
26739 PyThreadState* __tstate = wxPyBeginAllowThreads();
26740 (arg1)->FitInside();
26741
26742 wxPyEndAllowThreads(__tstate);
26743 if (PyErr_Occurred()) SWIG_fail;
26744 }
26745 Py_INCREF(Py_None); resultobj = Py_None;
26746 return resultobj;
26747 fail:
26748 return NULL;
26749 }
26750
26751
26752 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26753 PyObject *resultobj;
26754 wxWindow *arg1 = (wxWindow *) 0 ;
26755 int arg2 ;
26756 int arg3 ;
26757 int arg4 = (int) -1 ;
26758 int arg5 = (int) -1 ;
26759 int arg6 = (int) -1 ;
26760 int arg7 = (int) -1 ;
26761 PyObject * obj0 = 0 ;
26762 PyObject * obj1 = 0 ;
26763 PyObject * obj2 = 0 ;
26764 PyObject * obj3 = 0 ;
26765 PyObject * obj4 = 0 ;
26766 PyObject * obj5 = 0 ;
26767 PyObject * obj6 = 0 ;
26768 char *kwnames[] = {
26769 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26770 };
26771
26772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26774 if (SWIG_arg_fail(1)) SWIG_fail;
26775 {
26776 arg2 = (int)(SWIG_As_int(obj1));
26777 if (SWIG_arg_fail(2)) SWIG_fail;
26778 }
26779 {
26780 arg3 = (int)(SWIG_As_int(obj2));
26781 if (SWIG_arg_fail(3)) SWIG_fail;
26782 }
26783 if (obj3) {
26784 {
26785 arg4 = (int)(SWIG_As_int(obj3));
26786 if (SWIG_arg_fail(4)) SWIG_fail;
26787 }
26788 }
26789 if (obj4) {
26790 {
26791 arg5 = (int)(SWIG_As_int(obj4));
26792 if (SWIG_arg_fail(5)) SWIG_fail;
26793 }
26794 }
26795 if (obj5) {
26796 {
26797 arg6 = (int)(SWIG_As_int(obj5));
26798 if (SWIG_arg_fail(6)) SWIG_fail;
26799 }
26800 }
26801 if (obj6) {
26802 {
26803 arg7 = (int)(SWIG_As_int(obj6));
26804 if (SWIG_arg_fail(7)) SWIG_fail;
26805 }
26806 }
26807 {
26808 PyThreadState* __tstate = wxPyBeginAllowThreads();
26809 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26810
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 Py_INCREF(Py_None); resultobj = Py_None;
26815 return resultobj;
26816 fail:
26817 return NULL;
26818 }
26819
26820
26821 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26822 PyObject *resultobj;
26823 wxWindow *arg1 = (wxWindow *) 0 ;
26824 wxSize *arg2 = 0 ;
26825 wxSize const &arg3_defvalue = wxDefaultSize ;
26826 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26827 wxSize const &arg4_defvalue = wxDefaultSize ;
26828 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26829 wxSize temp2 ;
26830 wxSize temp3 ;
26831 wxSize temp4 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 PyObject * obj2 = 0 ;
26835 PyObject * obj3 = 0 ;
26836 char *kwnames[] = {
26837 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26838 };
26839
26840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26842 if (SWIG_arg_fail(1)) SWIG_fail;
26843 {
26844 arg2 = &temp2;
26845 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26846 }
26847 if (obj2) {
26848 {
26849 arg3 = &temp3;
26850 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26851 }
26852 }
26853 if (obj3) {
26854 {
26855 arg4 = &temp4;
26856 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26857 }
26858 }
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26862
26863 wxPyEndAllowThreads(__tstate);
26864 if (PyErr_Occurred()) SWIG_fail;
26865 }
26866 Py_INCREF(Py_None); resultobj = Py_None;
26867 return resultobj;
26868 fail:
26869 return NULL;
26870 }
26871
26872
26873 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26874 PyObject *resultobj;
26875 wxWindow *arg1 = (wxWindow *) 0 ;
26876 int arg2 ;
26877 int arg3 ;
26878 int arg4 = (int) -1 ;
26879 int arg5 = (int) -1 ;
26880 PyObject * obj0 = 0 ;
26881 PyObject * obj1 = 0 ;
26882 PyObject * obj2 = 0 ;
26883 PyObject * obj3 = 0 ;
26884 PyObject * obj4 = 0 ;
26885 char *kwnames[] = {
26886 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26887 };
26888
26889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26891 if (SWIG_arg_fail(1)) SWIG_fail;
26892 {
26893 arg2 = (int)(SWIG_As_int(obj1));
26894 if (SWIG_arg_fail(2)) SWIG_fail;
26895 }
26896 {
26897 arg3 = (int)(SWIG_As_int(obj2));
26898 if (SWIG_arg_fail(3)) SWIG_fail;
26899 }
26900 if (obj3) {
26901 {
26902 arg4 = (int)(SWIG_As_int(obj3));
26903 if (SWIG_arg_fail(4)) SWIG_fail;
26904 }
26905 }
26906 if (obj4) {
26907 {
26908 arg5 = (int)(SWIG_As_int(obj4));
26909 if (SWIG_arg_fail(5)) SWIG_fail;
26910 }
26911 }
26912 {
26913 PyThreadState* __tstate = wxPyBeginAllowThreads();
26914 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26915
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 Py_INCREF(Py_None); resultobj = Py_None;
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26927 PyObject *resultobj;
26928 wxWindow *arg1 = (wxWindow *) 0 ;
26929 wxSize *arg2 = 0 ;
26930 wxSize const &arg3_defvalue = wxDefaultSize ;
26931 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26932 wxSize temp2 ;
26933 wxSize temp3 ;
26934 PyObject * obj0 = 0 ;
26935 PyObject * obj1 = 0 ;
26936 PyObject * obj2 = 0 ;
26937 char *kwnames[] = {
26938 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26939 };
26940
26941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26943 if (SWIG_arg_fail(1)) SWIG_fail;
26944 {
26945 arg2 = &temp2;
26946 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26947 }
26948 if (obj2) {
26949 {
26950 arg3 = &temp3;
26951 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26952 }
26953 }
26954 {
26955 PyThreadState* __tstate = wxPyBeginAllowThreads();
26956 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26957
26958 wxPyEndAllowThreads(__tstate);
26959 if (PyErr_Occurred()) SWIG_fail;
26960 }
26961 Py_INCREF(Py_None); resultobj = Py_None;
26962 return resultobj;
26963 fail:
26964 return NULL;
26965 }
26966
26967
26968 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26969 PyObject *resultobj;
26970 wxWindow *arg1 = (wxWindow *) 0 ;
26971 wxSize result;
26972 PyObject * obj0 = 0 ;
26973 char *kwnames[] = {
26974 (char *) "self", NULL
26975 };
26976
26977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26979 if (SWIG_arg_fail(1)) SWIG_fail;
26980 {
26981 PyThreadState* __tstate = wxPyBeginAllowThreads();
26982 result = ((wxWindow const *)arg1)->GetMaxSize();
26983
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 wxSize * resultptr;
26989 resultptr = new wxSize((wxSize &)(result));
26990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26991 }
26992 return resultobj;
26993 fail:
26994 return NULL;
26995 }
26996
26997
26998 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26999 PyObject *resultobj;
27000 wxWindow *arg1 = (wxWindow *) 0 ;
27001 wxSize result;
27002 PyObject * obj0 = 0 ;
27003 char *kwnames[] = {
27004 (char *) "self", NULL
27005 };
27006
27007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27009 if (SWIG_arg_fail(1)) SWIG_fail;
27010 {
27011 PyThreadState* __tstate = wxPyBeginAllowThreads();
27012 result = ((wxWindow const *)arg1)->GetMinSize();
27013
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 {
27018 wxSize * resultptr;
27019 resultptr = new wxSize((wxSize &)(result));
27020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27021 }
27022 return resultobj;
27023 fail:
27024 return NULL;
27025 }
27026
27027
27028 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj;
27030 wxWindow *arg1 = (wxWindow *) 0 ;
27031 wxSize *arg2 = 0 ;
27032 wxSize temp2 ;
27033 PyObject * obj0 = 0 ;
27034 PyObject * obj1 = 0 ;
27035 char *kwnames[] = {
27036 (char *) "self",(char *) "minSize", NULL
27037 };
27038
27039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27041 if (SWIG_arg_fail(1)) SWIG_fail;
27042 {
27043 arg2 = &temp2;
27044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27045 }
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 (arg1)->SetMinSize((wxSize const &)*arg2);
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 Py_INCREF(Py_None); resultobj = Py_None;
27054 return resultobj;
27055 fail:
27056 return NULL;
27057 }
27058
27059
27060 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27061 PyObject *resultobj;
27062 wxWindow *arg1 = (wxWindow *) 0 ;
27063 wxSize *arg2 = 0 ;
27064 wxSize temp2 ;
27065 PyObject * obj0 = 0 ;
27066 PyObject * obj1 = 0 ;
27067 char *kwnames[] = {
27068 (char *) "self",(char *) "maxSize", NULL
27069 };
27070
27071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27073 if (SWIG_arg_fail(1)) SWIG_fail;
27074 {
27075 arg2 = &temp2;
27076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27077 }
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 (arg1)->SetMaxSize((wxSize const &)*arg2);
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 Py_INCREF(Py_None); resultobj = Py_None;
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj;
27094 wxWindow *arg1 = (wxWindow *) 0 ;
27095 int result;
27096 PyObject * obj0 = 0 ;
27097 char *kwnames[] = {
27098 (char *) "self", NULL
27099 };
27100
27101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27103 if (SWIG_arg_fail(1)) SWIG_fail;
27104 {
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27107
27108 wxPyEndAllowThreads(__tstate);
27109 if (PyErr_Occurred()) SWIG_fail;
27110 }
27111 {
27112 resultobj = SWIG_From_int((int)(result));
27113 }
27114 return resultobj;
27115 fail:
27116 return NULL;
27117 }
27118
27119
27120 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27121 PyObject *resultobj;
27122 wxWindow *arg1 = (wxWindow *) 0 ;
27123 int result;
27124 PyObject * obj0 = 0 ;
27125 char *kwnames[] = {
27126 (char *) "self", NULL
27127 };
27128
27129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27131 if (SWIG_arg_fail(1)) SWIG_fail;
27132 {
27133 PyThreadState* __tstate = wxPyBeginAllowThreads();
27134 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27135
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 {
27140 resultobj = SWIG_From_int((int)(result));
27141 }
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27149 PyObject *resultobj;
27150 wxWindow *arg1 = (wxWindow *) 0 ;
27151 int result;
27152 PyObject * obj0 = 0 ;
27153 char *kwnames[] = {
27154 (char *) "self", NULL
27155 };
27156
27157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27159 if (SWIG_arg_fail(1)) SWIG_fail;
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27163
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 resultobj = SWIG_From_int((int)(result));
27169 }
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxWindow *arg1 = (wxWindow *) 0 ;
27179 int result;
27180 PyObject * obj0 = 0 ;
27181 char *kwnames[] = {
27182 (char *) "self", NULL
27183 };
27184
27185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(1)) SWIG_fail;
27188 {
27189 PyThreadState* __tstate = wxPyBeginAllowThreads();
27190 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27191
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 resultobj = SWIG_From_int((int)(result));
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj;
27206 wxWindow *arg1 = (wxWindow *) 0 ;
27207 wxSize *arg2 = 0 ;
27208 wxSize temp2 ;
27209 PyObject * obj0 = 0 ;
27210 PyObject * obj1 = 0 ;
27211 char *kwnames[] = {
27212 (char *) "self",(char *) "size", NULL
27213 };
27214
27215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27217 if (SWIG_arg_fail(1)) SWIG_fail;
27218 {
27219 arg2 = &temp2;
27220 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27221 }
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27225
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 Py_INCREF(Py_None); resultobj = Py_None;
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj;
27238 wxWindow *arg1 = (wxWindow *) 0 ;
27239 int arg2 ;
27240 int arg3 ;
27241 PyObject * obj0 = 0 ;
27242 PyObject * obj1 = 0 ;
27243 PyObject * obj2 = 0 ;
27244 char *kwnames[] = {
27245 (char *) "self",(char *) "w",(char *) "h", NULL
27246 };
27247
27248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(1)) SWIG_fail;
27251 {
27252 arg2 = (int)(SWIG_As_int(obj1));
27253 if (SWIG_arg_fail(2)) SWIG_fail;
27254 }
27255 {
27256 arg3 = (int)(SWIG_As_int(obj2));
27257 if (SWIG_arg_fail(3)) SWIG_fail;
27258 }
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 (arg1)->SetVirtualSize(arg2,arg3);
27262
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 Py_INCREF(Py_None); resultobj = Py_None;
27267 return resultobj;
27268 fail:
27269 return NULL;
27270 }
27271
27272
27273 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27274 PyObject *resultobj;
27275 wxWindow *arg1 = (wxWindow *) 0 ;
27276 wxSize result;
27277 PyObject * obj0 = 0 ;
27278 char *kwnames[] = {
27279 (char *) "self", NULL
27280 };
27281
27282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27284 if (SWIG_arg_fail(1)) SWIG_fail;
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = ((wxWindow const *)arg1)->GetVirtualSize();
27288
27289 wxPyEndAllowThreads(__tstate);
27290 if (PyErr_Occurred()) SWIG_fail;
27291 }
27292 {
27293 wxSize * resultptr;
27294 resultptr = new wxSize((wxSize &)(result));
27295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27296 }
27297 return resultobj;
27298 fail:
27299 return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxWindow *arg1 = (wxWindow *) 0 ;
27306 int *arg2 = (int *) 0 ;
27307 int *arg3 = (int *) 0 ;
27308 int temp2 ;
27309 int res2 = 0 ;
27310 int temp3 ;
27311 int res3 = 0 ;
27312 PyObject * obj0 = 0 ;
27313 char *kwnames[] = {
27314 (char *) "self", NULL
27315 };
27316
27317 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27318 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27321 if (SWIG_arg_fail(1)) SWIG_fail;
27322 {
27323 PyThreadState* __tstate = wxPyBeginAllowThreads();
27324 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27325
27326 wxPyEndAllowThreads(__tstate);
27327 if (PyErr_Occurred()) SWIG_fail;
27328 }
27329 Py_INCREF(Py_None); resultobj = Py_None;
27330 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27331 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27332 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27333 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27334 return resultobj;
27335 fail:
27336 return NULL;
27337 }
27338
27339
27340 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27341 PyObject *resultobj;
27342 wxWindow *arg1 = (wxWindow *) 0 ;
27343 wxSize result;
27344 PyObject * obj0 = 0 ;
27345 char *kwnames[] = {
27346 (char *) "self", NULL
27347 };
27348
27349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27351 if (SWIG_arg_fail(1)) SWIG_fail;
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27355
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 {
27360 wxSize * resultptr;
27361 resultptr = new wxSize((wxSize &)(result));
27362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27363 }
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27371 PyObject *resultobj;
27372 wxWindow *arg1 = (wxWindow *) 0 ;
27373 bool arg2 = (bool) true ;
27374 bool result;
27375 PyObject * obj0 = 0 ;
27376 PyObject * obj1 = 0 ;
27377 char *kwnames[] = {
27378 (char *) "self",(char *) "show", NULL
27379 };
27380
27381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27383 if (SWIG_arg_fail(1)) SWIG_fail;
27384 if (obj1) {
27385 {
27386 arg2 = (bool)(SWIG_As_bool(obj1));
27387 if (SWIG_arg_fail(2)) SWIG_fail;
27388 }
27389 }
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = (bool)(arg1)->Show(arg2);
27393
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 {
27398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27399 }
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj;
27408 wxWindow *arg1 = (wxWindow *) 0 ;
27409 bool result;
27410 PyObject * obj0 = 0 ;
27411 char *kwnames[] = {
27412 (char *) "self", NULL
27413 };
27414
27415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27417 if (SWIG_arg_fail(1)) SWIG_fail;
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 result = (bool)(arg1)->Hide();
27421
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 {
27426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27427 }
27428 return resultobj;
27429 fail:
27430 return NULL;
27431 }
27432
27433
27434 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27435 PyObject *resultobj;
27436 wxWindow *arg1 = (wxWindow *) 0 ;
27437 bool arg2 = (bool) true ;
27438 bool result;
27439 PyObject * obj0 = 0 ;
27440 PyObject * obj1 = 0 ;
27441 char *kwnames[] = {
27442 (char *) "self",(char *) "enable", NULL
27443 };
27444
27445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27447 if (SWIG_arg_fail(1)) SWIG_fail;
27448 if (obj1) {
27449 {
27450 arg2 = (bool)(SWIG_As_bool(obj1));
27451 if (SWIG_arg_fail(2)) SWIG_fail;
27452 }
27453 }
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = (bool)(arg1)->Enable(arg2);
27457
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj;
27472 wxWindow *arg1 = (wxWindow *) 0 ;
27473 bool result;
27474 PyObject * obj0 = 0 ;
27475 char *kwnames[] = {
27476 (char *) "self", NULL
27477 };
27478
27479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27481 if (SWIG_arg_fail(1)) SWIG_fail;
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 result = (bool)(arg1)->Disable();
27485
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 {
27490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27491 }
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27499 PyObject *resultobj;
27500 wxWindow *arg1 = (wxWindow *) 0 ;
27501 bool result;
27502 PyObject * obj0 = 0 ;
27503 char *kwnames[] = {
27504 (char *) "self", NULL
27505 };
27506
27507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27509 if (SWIG_arg_fail(1)) SWIG_fail;
27510 {
27511 PyThreadState* __tstate = wxPyBeginAllowThreads();
27512 result = (bool)((wxWindow const *)arg1)->IsShown();
27513
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 {
27518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27519 }
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj;
27528 wxWindow *arg1 = (wxWindow *) 0 ;
27529 bool result;
27530 PyObject * obj0 = 0 ;
27531 char *kwnames[] = {
27532 (char *) "self", NULL
27533 };
27534
27535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27537 if (SWIG_arg_fail(1)) SWIG_fail;
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27541
27542 wxPyEndAllowThreads(__tstate);
27543 if (PyErr_Occurred()) SWIG_fail;
27544 }
27545 {
27546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27547 }
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj;
27556 wxWindow *arg1 = (wxWindow *) 0 ;
27557 long arg2 ;
27558 PyObject * obj0 = 0 ;
27559 PyObject * obj1 = 0 ;
27560 char *kwnames[] = {
27561 (char *) "self",(char *) "style", NULL
27562 };
27563
27564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27566 if (SWIG_arg_fail(1)) SWIG_fail;
27567 {
27568 arg2 = (long)(SWIG_As_long(obj1));
27569 if (SWIG_arg_fail(2)) SWIG_fail;
27570 }
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 (arg1)->SetWindowStyleFlag(arg2);
27574
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 Py_INCREF(Py_None); resultobj = Py_None;
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27586 PyObject *resultobj;
27587 wxWindow *arg1 = (wxWindow *) 0 ;
27588 long result;
27589 PyObject * obj0 = 0 ;
27590 char *kwnames[] = {
27591 (char *) "self", NULL
27592 };
27593
27594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27596 if (SWIG_arg_fail(1)) SWIG_fail;
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27600
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 {
27605 resultobj = SWIG_From_long((long)(result));
27606 }
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj;
27615 wxWindow *arg1 = (wxWindow *) 0 ;
27616 int arg2 ;
27617 bool result;
27618 PyObject * obj0 = 0 ;
27619 PyObject * obj1 = 0 ;
27620 char *kwnames[] = {
27621 (char *) "self",(char *) "flag", NULL
27622 };
27623
27624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27626 if (SWIG_arg_fail(1)) SWIG_fail;
27627 {
27628 arg2 = (int)(SWIG_As_int(obj1));
27629 if (SWIG_arg_fail(2)) SWIG_fail;
27630 }
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27634
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 {
27639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27640 }
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27648 PyObject *resultobj;
27649 wxWindow *arg1 = (wxWindow *) 0 ;
27650 bool result;
27651 PyObject * obj0 = 0 ;
27652 char *kwnames[] = {
27653 (char *) "self", NULL
27654 };
27655
27656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27658 if (SWIG_arg_fail(1)) SWIG_fail;
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = (bool)((wxWindow const *)arg1)->IsRetained();
27662
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 {
27667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27668 }
27669 return resultobj;
27670 fail:
27671 return NULL;
27672 }
27673
27674
27675 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27676 PyObject *resultobj;
27677 wxWindow *arg1 = (wxWindow *) 0 ;
27678 long arg2 ;
27679 PyObject * obj0 = 0 ;
27680 PyObject * obj1 = 0 ;
27681 char *kwnames[] = {
27682 (char *) "self",(char *) "exStyle", NULL
27683 };
27684
27685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27687 if (SWIG_arg_fail(1)) SWIG_fail;
27688 {
27689 arg2 = (long)(SWIG_As_long(obj1));
27690 if (SWIG_arg_fail(2)) SWIG_fail;
27691 }
27692 {
27693 PyThreadState* __tstate = wxPyBeginAllowThreads();
27694 (arg1)->SetExtraStyle(arg2);
27695
27696 wxPyEndAllowThreads(__tstate);
27697 if (PyErr_Occurred()) SWIG_fail;
27698 }
27699 Py_INCREF(Py_None); resultobj = Py_None;
27700 return resultobj;
27701 fail:
27702 return NULL;
27703 }
27704
27705
27706 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27707 PyObject *resultobj;
27708 wxWindow *arg1 = (wxWindow *) 0 ;
27709 long result;
27710 PyObject * obj0 = 0 ;
27711 char *kwnames[] = {
27712 (char *) "self", NULL
27713 };
27714
27715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27717 if (SWIG_arg_fail(1)) SWIG_fail;
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27721
27722 wxPyEndAllowThreads(__tstate);
27723 if (PyErr_Occurred()) SWIG_fail;
27724 }
27725 {
27726 resultobj = SWIG_From_long((long)(result));
27727 }
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj;
27736 wxWindow *arg1 = (wxWindow *) 0 ;
27737 bool arg2 = (bool) true ;
27738 PyObject * obj0 = 0 ;
27739 PyObject * obj1 = 0 ;
27740 char *kwnames[] = {
27741 (char *) "self",(char *) "modal", NULL
27742 };
27743
27744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27746 if (SWIG_arg_fail(1)) SWIG_fail;
27747 if (obj1) {
27748 {
27749 arg2 = (bool)(SWIG_As_bool(obj1));
27750 if (SWIG_arg_fail(2)) SWIG_fail;
27751 }
27752 }
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 (arg1)->MakeModal(arg2);
27756
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 Py_INCREF(Py_None); resultobj = Py_None;
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27768 PyObject *resultobj;
27769 wxWindow *arg1 = (wxWindow *) 0 ;
27770 bool arg2 ;
27771 PyObject * obj0 = 0 ;
27772 PyObject * obj1 = 0 ;
27773 char *kwnames[] = {
27774 (char *) "self",(char *) "enableTheme", NULL
27775 };
27776
27777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27779 if (SWIG_arg_fail(1)) SWIG_fail;
27780 {
27781 arg2 = (bool)(SWIG_As_bool(obj1));
27782 if (SWIG_arg_fail(2)) SWIG_fail;
27783 }
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 (arg1)->SetThemeEnabled(arg2);
27787
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 Py_INCREF(Py_None); resultobj = Py_None;
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27799 PyObject *resultobj;
27800 wxWindow *arg1 = (wxWindow *) 0 ;
27801 bool result;
27802 PyObject * obj0 = 0 ;
27803 char *kwnames[] = {
27804 (char *) "self", NULL
27805 };
27806
27807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27809 if (SWIG_arg_fail(1)) SWIG_fail;
27810 {
27811 PyThreadState* __tstate = wxPyBeginAllowThreads();
27812 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27813
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 {
27818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27819 }
27820 return resultobj;
27821 fail:
27822 return NULL;
27823 }
27824
27825
27826 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj;
27828 wxWindow *arg1 = (wxWindow *) 0 ;
27829 PyObject * obj0 = 0 ;
27830 char *kwnames[] = {
27831 (char *) "self", NULL
27832 };
27833
27834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27836 if (SWIG_arg_fail(1)) SWIG_fail;
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 (arg1)->SetFocus();
27840
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 Py_INCREF(Py_None); resultobj = Py_None;
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27852 PyObject *resultobj;
27853 wxWindow *arg1 = (wxWindow *) 0 ;
27854 PyObject * obj0 = 0 ;
27855 char *kwnames[] = {
27856 (char *) "self", NULL
27857 };
27858
27859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27861 if (SWIG_arg_fail(1)) SWIG_fail;
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 (arg1)->SetFocusFromKbd();
27865
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 Py_INCREF(Py_None); resultobj = Py_None;
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27877 PyObject *resultobj;
27878 wxWindow *result;
27879 char *kwnames[] = {
27880 NULL
27881 };
27882
27883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27884 {
27885 if (!wxPyCheckForApp()) SWIG_fail;
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 result = (wxWindow *)wxWindow::FindFocus();
27888
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 {
27893 resultobj = wxPyMake_wxObject(result, 0);
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27902 PyObject *resultobj;
27903 wxWindow *arg1 = (wxWindow *) 0 ;
27904 bool result;
27905 PyObject * obj0 = 0 ;
27906 char *kwnames[] = {
27907 (char *) "self", NULL
27908 };
27909
27910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27912 if (SWIG_arg_fail(1)) SWIG_fail;
27913 {
27914 PyThreadState* __tstate = wxPyBeginAllowThreads();
27915 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27916
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 {
27921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27922 }
27923 return resultobj;
27924 fail:
27925 return NULL;
27926 }
27927
27928
27929 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27930 PyObject *resultobj;
27931 wxWindow *arg1 = (wxWindow *) 0 ;
27932 bool result;
27933 PyObject * obj0 = 0 ;
27934 char *kwnames[] = {
27935 (char *) "self", NULL
27936 };
27937
27938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27950 }
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj;
27959 wxWindow *arg1 = (wxWindow *) 0 ;
27960 wxWindow *result;
27961 PyObject * obj0 = 0 ;
27962 char *kwnames[] = {
27963 (char *) "self", NULL
27964 };
27965
27966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27968 if (SWIG_arg_fail(1)) SWIG_fail;
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27972
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 {
27977 resultobj = wxPyMake_wxObject(result, 0);
27978 }
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj;
27987 wxWindow *arg1 = (wxWindow *) 0 ;
27988 wxWindow *arg2 = (wxWindow *) 0 ;
27989 wxWindow *result;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char *kwnames[] = {
27993 (char *) "self",(char *) "child", NULL
27994 };
27995
27996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27998 if (SWIG_arg_fail(1)) SWIG_fail;
27999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(2)) SWIG_fail;
28001 {
28002 PyThreadState* __tstate = wxPyBeginAllowThreads();
28003 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28004
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 {
28009 resultobj = wxPyMake_wxObject(result, 0);
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj;
28019 wxWindow *arg1 = (wxWindow *) 0 ;
28020 wxWindow *arg2 = (wxWindow *) 0 ;
28021 PyObject * obj0 = 0 ;
28022 PyObject * obj1 = 0 ;
28023 char *kwnames[] = {
28024 (char *) "self",(char *) "win", NULL
28025 };
28026
28027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28029 if (SWIG_arg_fail(1)) SWIG_fail;
28030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28031 if (SWIG_arg_fail(2)) SWIG_fail;
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 (arg1)->SetTmpDefaultItem(arg2);
28035
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 Py_INCREF(Py_None); resultobj = Py_None;
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj;
28048 wxWindow *arg1 = (wxWindow *) 0 ;
28049 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28050 bool result;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 char *kwnames[] = {
28054 (char *) "self",(char *) "flags", NULL
28055 };
28056
28057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28059 if (SWIG_arg_fail(1)) SWIG_fail;
28060 if (obj1) {
28061 {
28062 arg2 = (int)(SWIG_As_int(obj1));
28063 if (SWIG_arg_fail(2)) SWIG_fail;
28064 }
28065 }
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (bool)(arg1)->Navigate(arg2);
28069
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 {
28074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28075 }
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj;
28084 wxWindow *arg1 = (wxWindow *) 0 ;
28085 wxWindow *arg2 = (wxWindow *) 0 ;
28086 PyObject * obj0 = 0 ;
28087 PyObject * obj1 = 0 ;
28088 char *kwnames[] = {
28089 (char *) "self",(char *) "win", NULL
28090 };
28091
28092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28094 if (SWIG_arg_fail(1)) SWIG_fail;
28095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28096 if (SWIG_arg_fail(2)) SWIG_fail;
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 (arg1)->MoveAfterInTabOrder(arg2);
28100
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 Py_INCREF(Py_None); resultobj = Py_None;
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj;
28113 wxWindow *arg1 = (wxWindow *) 0 ;
28114 wxWindow *arg2 = (wxWindow *) 0 ;
28115 PyObject * obj0 = 0 ;
28116 PyObject * obj1 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "self",(char *) "win", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28125 if (SWIG_arg_fail(2)) SWIG_fail;
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 (arg1)->MoveBeforeInTabOrder(arg2);
28129
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 Py_INCREF(Py_None); resultobj = Py_None;
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28141 PyObject *resultobj;
28142 wxWindow *arg1 = (wxWindow *) 0 ;
28143 PyObject *result;
28144 PyObject * obj0 = 0 ;
28145 char *kwnames[] = {
28146 (char *) "self", NULL
28147 };
28148
28149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28151 if (SWIG_arg_fail(1)) SWIG_fail;
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 result = (PyObject *)wxWindow_GetChildren(arg1);
28155
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 resultobj = result;
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28167 PyObject *resultobj;
28168 wxWindow *arg1 = (wxWindow *) 0 ;
28169 wxWindow *result;
28170 PyObject * obj0 = 0 ;
28171 char *kwnames[] = {
28172 (char *) "self", NULL
28173 };
28174
28175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28177 if (SWIG_arg_fail(1)) SWIG_fail;
28178 {
28179 PyThreadState* __tstate = wxPyBeginAllowThreads();
28180 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28181
28182 wxPyEndAllowThreads(__tstate);
28183 if (PyErr_Occurred()) SWIG_fail;
28184 }
28185 {
28186 resultobj = wxPyMake_wxObject(result, 0);
28187 }
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj;
28196 wxWindow *arg1 = (wxWindow *) 0 ;
28197 wxWindow *result;
28198 PyObject * obj0 = 0 ;
28199 char *kwnames[] = {
28200 (char *) "self", NULL
28201 };
28202
28203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28205 if (SWIG_arg_fail(1)) SWIG_fail;
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28209
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 {
28214 resultobj = wxPyMake_wxObject(result, 0);
28215 }
28216 return resultobj;
28217 fail:
28218 return NULL;
28219 }
28220
28221
28222 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj;
28224 wxWindow *arg1 = (wxWindow *) 0 ;
28225 bool result;
28226 PyObject * obj0 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 {
28242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28243 }
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj;
28252 wxWindow *arg1 = (wxWindow *) 0 ;
28253 wxWindow *arg2 = (wxWindow *) 0 ;
28254 bool result;
28255 PyObject * obj0 = 0 ;
28256 PyObject * obj1 = 0 ;
28257 char *kwnames[] = {
28258 (char *) "self",(char *) "newParent", NULL
28259 };
28260
28261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28263 if (SWIG_arg_fail(1)) SWIG_fail;
28264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28265 if (SWIG_arg_fail(2)) SWIG_fail;
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 result = (bool)(arg1)->Reparent(arg2);
28269
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 {
28274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28275 }
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj;
28284 wxWindow *arg1 = (wxWindow *) 0 ;
28285 wxWindow *arg2 = (wxWindow *) 0 ;
28286 PyObject * obj0 = 0 ;
28287 PyObject * obj1 = 0 ;
28288 char *kwnames[] = {
28289 (char *) "self",(char *) "child", NULL
28290 };
28291
28292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28294 if (SWIG_arg_fail(1)) SWIG_fail;
28295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28296 if (SWIG_arg_fail(2)) SWIG_fail;
28297 {
28298 PyThreadState* __tstate = wxPyBeginAllowThreads();
28299 (arg1)->AddChild(arg2);
28300
28301 wxPyEndAllowThreads(__tstate);
28302 if (PyErr_Occurred()) SWIG_fail;
28303 }
28304 Py_INCREF(Py_None); resultobj = Py_None;
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28312 PyObject *resultobj;
28313 wxWindow *arg1 = (wxWindow *) 0 ;
28314 wxWindow *arg2 = (wxWindow *) 0 ;
28315 PyObject * obj0 = 0 ;
28316 PyObject * obj1 = 0 ;
28317 char *kwnames[] = {
28318 (char *) "self",(char *) "child", NULL
28319 };
28320
28321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28323 if (SWIG_arg_fail(1)) SWIG_fail;
28324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28325 if (SWIG_arg_fail(2)) SWIG_fail;
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 (arg1)->RemoveChild(arg2);
28329
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 Py_INCREF(Py_None); resultobj = Py_None;
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj;
28342 wxWindow *arg1 = (wxWindow *) 0 ;
28343 long arg2 ;
28344 wxWindow *result;
28345 PyObject * obj0 = 0 ;
28346 PyObject * obj1 = 0 ;
28347 char *kwnames[] = {
28348 (char *) "self",(char *) "winid", NULL
28349 };
28350
28351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28353 if (SWIG_arg_fail(1)) SWIG_fail;
28354 {
28355 arg2 = (long)(SWIG_As_long(obj1));
28356 if (SWIG_arg_fail(2)) SWIG_fail;
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (wxWindow *)(arg1)->FindWindow(arg2);
28361
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = wxPyMake_wxObject(result, 0);
28367 }
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj;
28376 wxWindow *arg1 = (wxWindow *) 0 ;
28377 wxString *arg2 = 0 ;
28378 wxWindow *result;
28379 bool temp2 = false ;
28380 PyObject * obj0 = 0 ;
28381 PyObject * obj1 = 0 ;
28382 char *kwnames[] = {
28383 (char *) "self",(char *) "name", NULL
28384 };
28385
28386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28388 if (SWIG_arg_fail(1)) SWIG_fail;
28389 {
28390 arg2 = wxString_in_helper(obj1);
28391 if (arg2 == NULL) SWIG_fail;
28392 temp2 = true;
28393 }
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = wxPyMake_wxObject(result, 0);
28403 }
28404 {
28405 if (temp2)
28406 delete arg2;
28407 }
28408 return resultobj;
28409 fail:
28410 {
28411 if (temp2)
28412 delete arg2;
28413 }
28414 return NULL;
28415 }
28416
28417
28418 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj;
28420 wxWindow *arg1 = (wxWindow *) 0 ;
28421 wxEvtHandler *result;
28422 PyObject * obj0 = 0 ;
28423 char *kwnames[] = {
28424 (char *) "self", NULL
28425 };
28426
28427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28429 if (SWIG_arg_fail(1)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 resultobj = wxPyMake_wxObject(result, 0);
28439 }
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj;
28448 wxWindow *arg1 = (wxWindow *) 0 ;
28449 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28450 PyObject * obj0 = 0 ;
28451 PyObject * obj1 = 0 ;
28452 char *kwnames[] = {
28453 (char *) "self",(char *) "handler", NULL
28454 };
28455
28456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28458 if (SWIG_arg_fail(1)) SWIG_fail;
28459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28460 if (SWIG_arg_fail(2)) SWIG_fail;
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 (arg1)->SetEventHandler(arg2);
28464
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 Py_INCREF(Py_None); resultobj = Py_None;
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28476 PyObject *resultobj;
28477 wxWindow *arg1 = (wxWindow *) 0 ;
28478 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28479 PyObject * obj0 = 0 ;
28480 PyObject * obj1 = 0 ;
28481 char *kwnames[] = {
28482 (char *) "self",(char *) "handler", NULL
28483 };
28484
28485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28487 if (SWIG_arg_fail(1)) SWIG_fail;
28488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28489 if (SWIG_arg_fail(2)) SWIG_fail;
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 (arg1)->PushEventHandler(arg2);
28493
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 Py_INCREF(Py_None); resultobj = Py_None;
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj;
28506 wxWindow *arg1 = (wxWindow *) 0 ;
28507 bool arg2 = (bool) false ;
28508 wxEvtHandler *result;
28509 PyObject * obj0 = 0 ;
28510 PyObject * obj1 = 0 ;
28511 char *kwnames[] = {
28512 (char *) "self",(char *) "deleteHandler", NULL
28513 };
28514
28515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28517 if (SWIG_arg_fail(1)) SWIG_fail;
28518 if (obj1) {
28519 {
28520 arg2 = (bool)(SWIG_As_bool(obj1));
28521 if (SWIG_arg_fail(2)) SWIG_fail;
28522 }
28523 }
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28527
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 {
28532 resultobj = wxPyMake_wxObject(result, 0);
28533 }
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxWindow *arg1 = (wxWindow *) 0 ;
28543 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28544 bool result;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "handler", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(2)) SWIG_fail;
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (bool)(arg1)->RemoveEventHandler(arg2);
28559
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 {
28564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28565 }
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj;
28574 wxWindow *arg1 = (wxWindow *) 0 ;
28575 wxValidator *arg2 = 0 ;
28576 PyObject * obj0 = 0 ;
28577 PyObject * obj1 = 0 ;
28578 char *kwnames[] = {
28579 (char *) "self",(char *) "validator", NULL
28580 };
28581
28582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28584 if (SWIG_arg_fail(1)) SWIG_fail;
28585 {
28586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28587 if (SWIG_arg_fail(2)) SWIG_fail;
28588 if (arg2 == NULL) {
28589 SWIG_null_ref("wxValidator");
28590 }
28591 if (SWIG_arg_fail(2)) SWIG_fail;
28592 }
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 (arg1)->SetValidator((wxValidator const &)*arg2);
28596
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 Py_INCREF(Py_None); resultobj = Py_None;
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28608 PyObject *resultobj;
28609 wxWindow *arg1 = (wxWindow *) 0 ;
28610 wxValidator *result;
28611 PyObject * obj0 = 0 ;
28612 char *kwnames[] = {
28613 (char *) "self", NULL
28614 };
28615
28616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28618 if (SWIG_arg_fail(1)) SWIG_fail;
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = (wxValidator *)(arg1)->GetValidator();
28622
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 resultobj = wxPyMake_wxObject(result, 0);
28628 }
28629 return resultobj;
28630 fail:
28631 return NULL;
28632 }
28633
28634
28635 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28636 PyObject *resultobj;
28637 wxWindow *arg1 = (wxWindow *) 0 ;
28638 bool result;
28639 PyObject * obj0 = 0 ;
28640 char *kwnames[] = {
28641 (char *) "self", NULL
28642 };
28643
28644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(1)) SWIG_fail;
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 result = (bool)(arg1)->Validate();
28650
28651 wxPyEndAllowThreads(__tstate);
28652 if (PyErr_Occurred()) SWIG_fail;
28653 }
28654 {
28655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28656 }
28657 return resultobj;
28658 fail:
28659 return NULL;
28660 }
28661
28662
28663 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28664 PyObject *resultobj;
28665 wxWindow *arg1 = (wxWindow *) 0 ;
28666 bool result;
28667 PyObject * obj0 = 0 ;
28668 char *kwnames[] = {
28669 (char *) "self", NULL
28670 };
28671
28672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28674 if (SWIG_arg_fail(1)) SWIG_fail;
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (bool)(arg1)->TransferDataToWindow();
28678
28679 wxPyEndAllowThreads(__tstate);
28680 if (PyErr_Occurred()) SWIG_fail;
28681 }
28682 {
28683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28684 }
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28692 PyObject *resultobj;
28693 wxWindow *arg1 = (wxWindow *) 0 ;
28694 bool result;
28695 PyObject * obj0 = 0 ;
28696 char *kwnames[] = {
28697 (char *) "self", NULL
28698 };
28699
28700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28702 if (SWIG_arg_fail(1)) SWIG_fail;
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (bool)(arg1)->TransferDataFromWindow();
28706
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 {
28711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28712 }
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj;
28721 wxWindow *arg1 = (wxWindow *) 0 ;
28722 PyObject * obj0 = 0 ;
28723 char *kwnames[] = {
28724 (char *) "self", NULL
28725 };
28726
28727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28729 if (SWIG_arg_fail(1)) SWIG_fail;
28730 {
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 (arg1)->InitDialog();
28733
28734 wxPyEndAllowThreads(__tstate);
28735 if (PyErr_Occurred()) SWIG_fail;
28736 }
28737 Py_INCREF(Py_None); resultobj = Py_None;
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28745 PyObject *resultobj;
28746 wxWindow *arg1 = (wxWindow *) 0 ;
28747 wxAcceleratorTable *arg2 = 0 ;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 char *kwnames[] = {
28751 (char *) "self",(char *) "accel", NULL
28752 };
28753
28754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(1)) SWIG_fail;
28757 {
28758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28759 if (SWIG_arg_fail(2)) SWIG_fail;
28760 if (arg2 == NULL) {
28761 SWIG_null_ref("wxAcceleratorTable");
28762 }
28763 if (SWIG_arg_fail(2)) SWIG_fail;
28764 }
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28768
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 Py_INCREF(Py_None); resultobj = Py_None;
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28780 PyObject *resultobj;
28781 wxWindow *arg1 = (wxWindow *) 0 ;
28782 wxAcceleratorTable *result;
28783 PyObject * obj0 = 0 ;
28784 char *kwnames[] = {
28785 (char *) "self", NULL
28786 };
28787
28788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28790 if (SWIG_arg_fail(1)) SWIG_fail;
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28794
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28806 PyObject *resultobj;
28807 wxWindow *arg1 = (wxWindow *) 0 ;
28808 int arg2 ;
28809 int arg3 ;
28810 int arg4 ;
28811 bool result;
28812 PyObject * obj0 = 0 ;
28813 PyObject * obj1 = 0 ;
28814 PyObject * obj2 = 0 ;
28815 PyObject * obj3 = 0 ;
28816 char *kwnames[] = {
28817 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28818 };
28819
28820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28822 if (SWIG_arg_fail(1)) SWIG_fail;
28823 {
28824 arg2 = (int)(SWIG_As_int(obj1));
28825 if (SWIG_arg_fail(2)) SWIG_fail;
28826 }
28827 {
28828 arg3 = (int)(SWIG_As_int(obj2));
28829 if (SWIG_arg_fail(3)) SWIG_fail;
28830 }
28831 {
28832 arg4 = (int)(SWIG_As_int(obj3));
28833 if (SWIG_arg_fail(4)) SWIG_fail;
28834 }
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28838
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 {
28843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28844 }
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj;
28853 wxWindow *arg1 = (wxWindow *) 0 ;
28854 int arg2 ;
28855 bool result;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 char *kwnames[] = {
28859 (char *) "self",(char *) "hotkeyId", NULL
28860 };
28861
28862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28864 if (SWIG_arg_fail(1)) SWIG_fail;
28865 {
28866 arg2 = (int)(SWIG_As_int(obj1));
28867 if (SWIG_arg_fail(2)) SWIG_fail;
28868 }
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28872
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 {
28877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28878 }
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj;
28887 wxWindow *arg1 = (wxWindow *) 0 ;
28888 wxPoint *arg2 = 0 ;
28889 wxPoint result;
28890 wxPoint temp2 ;
28891 PyObject * obj0 = 0 ;
28892 PyObject * obj1 = 0 ;
28893 char *kwnames[] = {
28894 (char *) "self",(char *) "pt", NULL
28895 };
28896
28897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28899 if (SWIG_arg_fail(1)) SWIG_fail;
28900 {
28901 arg2 = &temp2;
28902 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28903 }
28904 {
28905 PyThreadState* __tstate = wxPyBeginAllowThreads();
28906 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28907
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 {
28912 wxPoint * resultptr;
28913 resultptr = new wxPoint((wxPoint &)(result));
28914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28915 }
28916 return resultobj;
28917 fail:
28918 return NULL;
28919 }
28920
28921
28922 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28923 PyObject *resultobj;
28924 wxWindow *arg1 = (wxWindow *) 0 ;
28925 wxSize *arg2 = 0 ;
28926 wxSize result;
28927 wxSize temp2 ;
28928 PyObject * obj0 = 0 ;
28929 PyObject * obj1 = 0 ;
28930 char *kwnames[] = {
28931 (char *) "self",(char *) "sz", NULL
28932 };
28933
28934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28936 if (SWIG_arg_fail(1)) SWIG_fail;
28937 {
28938 arg2 = &temp2;
28939 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28940 }
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28944
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 {
28949 wxSize * resultptr;
28950 resultptr = new wxSize((wxSize &)(result));
28951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28952 }
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28960 PyObject *resultobj;
28961 wxWindow *arg1 = (wxWindow *) 0 ;
28962 wxPoint *arg2 = 0 ;
28963 wxPoint result;
28964 wxPoint temp2 ;
28965 PyObject * obj0 = 0 ;
28966 PyObject * obj1 = 0 ;
28967 char *kwnames[] = {
28968 (char *) "self",(char *) "pt", NULL
28969 };
28970
28971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28973 if (SWIG_arg_fail(1)) SWIG_fail;
28974 {
28975 arg2 = &temp2;
28976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28977 }
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28981
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 {
28986 wxPoint * resultptr;
28987 resultptr = new wxPoint((wxPoint &)(result));
28988 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28989 }
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28997 PyObject *resultobj;
28998 wxWindow *arg1 = (wxWindow *) 0 ;
28999 wxSize *arg2 = 0 ;
29000 wxSize result;
29001 wxSize temp2 ;
29002 PyObject * obj0 = 0 ;
29003 PyObject * obj1 = 0 ;
29004 char *kwnames[] = {
29005 (char *) "self",(char *) "sz", NULL
29006 };
29007
29008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29010 if (SWIG_arg_fail(1)) SWIG_fail;
29011 {
29012 arg2 = &temp2;
29013 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29014 }
29015 {
29016 PyThreadState* __tstate = wxPyBeginAllowThreads();
29017 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29018
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 {
29023 wxSize * resultptr;
29024 resultptr = new wxSize((wxSize &)(result));
29025 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29026 }
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj;
29035 wxWindow *arg1 = (wxWindow *) 0 ;
29036 wxPoint *arg2 = 0 ;
29037 wxPoint result;
29038 wxPoint temp2 ;
29039 PyObject * obj0 = 0 ;
29040 PyObject * obj1 = 0 ;
29041 char *kwnames[] = {
29042 (char *) "self",(char *) "pt", NULL
29043 };
29044
29045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29047 if (SWIG_arg_fail(1)) SWIG_fail;
29048 {
29049 arg2 = &temp2;
29050 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29051 }
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29055
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 {
29060 wxPoint * resultptr;
29061 resultptr = new wxPoint((wxPoint &)(result));
29062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29063 }
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj;
29072 wxWindow *arg1 = (wxWindow *) 0 ;
29073 wxSize *arg2 = 0 ;
29074 wxSize result;
29075 wxSize temp2 ;
29076 PyObject * obj0 = 0 ;
29077 PyObject * obj1 = 0 ;
29078 char *kwnames[] = {
29079 (char *) "self",(char *) "sz", NULL
29080 };
29081
29082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29084 if (SWIG_arg_fail(1)) SWIG_fail;
29085 {
29086 arg2 = &temp2;
29087 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29088 }
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29092
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 {
29097 wxSize * resultptr;
29098 resultptr = new wxSize((wxSize &)(result));
29099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29100 }
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj;
29109 wxWindow *arg1 = (wxWindow *) 0 ;
29110 int arg2 ;
29111 int arg3 ;
29112 PyObject * obj0 = 0 ;
29113 PyObject * obj1 = 0 ;
29114 PyObject * obj2 = 0 ;
29115 char *kwnames[] = {
29116 (char *) "self",(char *) "x",(char *) "y", NULL
29117 };
29118
29119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29121 if (SWIG_arg_fail(1)) SWIG_fail;
29122 {
29123 arg2 = (int)(SWIG_As_int(obj1));
29124 if (SWIG_arg_fail(2)) SWIG_fail;
29125 }
29126 {
29127 arg3 = (int)(SWIG_As_int(obj2));
29128 if (SWIG_arg_fail(3)) SWIG_fail;
29129 }
29130 {
29131 PyThreadState* __tstate = wxPyBeginAllowThreads();
29132 (arg1)->WarpPointer(arg2,arg3);
29133
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 Py_INCREF(Py_None); resultobj = Py_None;
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj;
29146 wxWindow *arg1 = (wxWindow *) 0 ;
29147 PyObject * obj0 = 0 ;
29148 char *kwnames[] = {
29149 (char *) "self", NULL
29150 };
29151
29152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29154 if (SWIG_arg_fail(1)) SWIG_fail;
29155 {
29156 PyThreadState* __tstate = wxPyBeginAllowThreads();
29157 (arg1)->CaptureMouse();
29158
29159 wxPyEndAllowThreads(__tstate);
29160 if (PyErr_Occurred()) SWIG_fail;
29161 }
29162 Py_INCREF(Py_None); resultobj = Py_None;
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29170 PyObject *resultobj;
29171 wxWindow *arg1 = (wxWindow *) 0 ;
29172 PyObject * obj0 = 0 ;
29173 char *kwnames[] = {
29174 (char *) "self", NULL
29175 };
29176
29177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29179 if (SWIG_arg_fail(1)) SWIG_fail;
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 (arg1)->ReleaseMouse();
29183
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 Py_INCREF(Py_None); resultobj = Py_None;
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29195 PyObject *resultobj;
29196 wxWindow *result;
29197 char *kwnames[] = {
29198 NULL
29199 };
29200
29201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29202 {
29203 if (!wxPyCheckForApp()) SWIG_fail;
29204 PyThreadState* __tstate = wxPyBeginAllowThreads();
29205 result = (wxWindow *)wxWindow::GetCapture();
29206
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 {
29211 resultobj = wxPyMake_wxObject(result, 0);
29212 }
29213 return resultobj;
29214 fail:
29215 return NULL;
29216 }
29217
29218
29219 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29220 PyObject *resultobj;
29221 wxWindow *arg1 = (wxWindow *) 0 ;
29222 bool result;
29223 PyObject * obj0 = 0 ;
29224 char *kwnames[] = {
29225 (char *) "self", NULL
29226 };
29227
29228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29230 if (SWIG_arg_fail(1)) SWIG_fail;
29231 {
29232 PyThreadState* __tstate = wxPyBeginAllowThreads();
29233 result = (bool)((wxWindow const *)arg1)->HasCapture();
29234
29235 wxPyEndAllowThreads(__tstate);
29236 if (PyErr_Occurred()) SWIG_fail;
29237 }
29238 {
29239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29240 }
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29248 PyObject *resultobj;
29249 wxWindow *arg1 = (wxWindow *) 0 ;
29250 bool arg2 = (bool) true ;
29251 wxRect *arg3 = (wxRect *) NULL ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 PyObject * obj2 = 0 ;
29255 char *kwnames[] = {
29256 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29257 };
29258
29259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29261 if (SWIG_arg_fail(1)) SWIG_fail;
29262 if (obj1) {
29263 {
29264 arg2 = (bool)(SWIG_As_bool(obj1));
29265 if (SWIG_arg_fail(2)) SWIG_fail;
29266 }
29267 }
29268 if (obj2) {
29269 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29270 if (SWIG_arg_fail(3)) SWIG_fail;
29271 }
29272 {
29273 PyThreadState* __tstate = wxPyBeginAllowThreads();
29274 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29275
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 Py_INCREF(Py_None); resultobj = Py_None;
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj;
29288 wxWindow *arg1 = (wxWindow *) 0 ;
29289 wxRect *arg2 = 0 ;
29290 bool arg3 = (bool) true ;
29291 wxRect temp2 ;
29292 PyObject * obj0 = 0 ;
29293 PyObject * obj1 = 0 ;
29294 PyObject * obj2 = 0 ;
29295 char *kwnames[] = {
29296 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29297 };
29298
29299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29301 if (SWIG_arg_fail(1)) SWIG_fail;
29302 {
29303 arg2 = &temp2;
29304 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29305 }
29306 if (obj2) {
29307 {
29308 arg3 = (bool)(SWIG_As_bool(obj2));
29309 if (SWIG_arg_fail(3)) SWIG_fail;
29310 }
29311 }
29312 {
29313 PyThreadState* __tstate = wxPyBeginAllowThreads();
29314 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29315
29316 wxPyEndAllowThreads(__tstate);
29317 if (PyErr_Occurred()) SWIG_fail;
29318 }
29319 Py_INCREF(Py_None); resultobj = Py_None;
29320 return resultobj;
29321 fail:
29322 return NULL;
29323 }
29324
29325
29326 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29327 PyObject *resultobj;
29328 wxWindow *arg1 = (wxWindow *) 0 ;
29329 PyObject * obj0 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29336 if (SWIG_arg_fail(1)) SWIG_fail;
29337 {
29338 PyThreadState* __tstate = wxPyBeginAllowThreads();
29339 (arg1)->Update();
29340
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 Py_INCREF(Py_None); resultobj = Py_None;
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj;
29353 wxWindow *arg1 = (wxWindow *) 0 ;
29354 PyObject * obj0 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(1)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 (arg1)->ClearBackground();
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 Py_INCREF(Py_None); resultobj = Py_None;
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj;
29378 wxWindow *arg1 = (wxWindow *) 0 ;
29379 PyObject * obj0 = 0 ;
29380 char *kwnames[] = {
29381 (char *) "self", NULL
29382 };
29383
29384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29386 if (SWIG_arg_fail(1)) SWIG_fail;
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 (arg1)->Freeze();
29390
29391 wxPyEndAllowThreads(__tstate);
29392 if (PyErr_Occurred()) SWIG_fail;
29393 }
29394 Py_INCREF(Py_None); resultobj = Py_None;
29395 return resultobj;
29396 fail:
29397 return NULL;
29398 }
29399
29400
29401 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29402 PyObject *resultobj;
29403 wxWindow *arg1 = (wxWindow *) 0 ;
29404 PyObject * obj0 = 0 ;
29405 char *kwnames[] = {
29406 (char *) "self", NULL
29407 };
29408
29409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29411 if (SWIG_arg_fail(1)) SWIG_fail;
29412 {
29413 PyThreadState* __tstate = wxPyBeginAllowThreads();
29414 (arg1)->Thaw();
29415
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 Py_INCREF(Py_None); resultobj = Py_None;
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29427 PyObject *resultobj;
29428 wxWindow *arg1 = (wxWindow *) 0 ;
29429 wxDC *arg2 = 0 ;
29430 PyObject * obj0 = 0 ;
29431 PyObject * obj1 = 0 ;
29432 char *kwnames[] = {
29433 (char *) "self",(char *) "dc", NULL
29434 };
29435
29436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29438 if (SWIG_arg_fail(1)) SWIG_fail;
29439 {
29440 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29441 if (SWIG_arg_fail(2)) SWIG_fail;
29442 if (arg2 == NULL) {
29443 SWIG_null_ref("wxDC");
29444 }
29445 if (SWIG_arg_fail(2)) SWIG_fail;
29446 }
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 (arg1)->PrepareDC(*arg2);
29450
29451 wxPyEndAllowThreads(__tstate);
29452 if (PyErr_Occurred()) SWIG_fail;
29453 }
29454 Py_INCREF(Py_None); resultobj = Py_None;
29455 return resultobj;
29456 fail:
29457 return NULL;
29458 }
29459
29460
29461 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29462 PyObject *resultobj;
29463 wxWindow *arg1 = (wxWindow *) 0 ;
29464 wxRegion *result;
29465 PyObject * obj0 = 0 ;
29466 char *kwnames[] = {
29467 (char *) "self", NULL
29468 };
29469
29470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29472 if (SWIG_arg_fail(1)) SWIG_fail;
29473 {
29474 PyThreadState* __tstate = wxPyBeginAllowThreads();
29475 {
29476 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29477 result = (wxRegion *) &_result_ref;
29478 }
29479
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29484 return resultobj;
29485 fail:
29486 return NULL;
29487 }
29488
29489
29490 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj;
29492 wxWindow *arg1 = (wxWindow *) 0 ;
29493 wxRect result;
29494 PyObject * obj0 = 0 ;
29495 char *kwnames[] = {
29496 (char *) "self", NULL
29497 };
29498
29499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29501 if (SWIG_arg_fail(1)) SWIG_fail;
29502 {
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29505
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 {
29510 wxRect * resultptr;
29511 resultptr = new wxRect((wxRect &)(result));
29512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29513 }
29514 return resultobj;
29515 fail:
29516 return NULL;
29517 }
29518
29519
29520 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29521 PyObject *resultobj;
29522 wxWindow *arg1 = (wxWindow *) 0 ;
29523 int arg2 ;
29524 int arg3 ;
29525 int arg4 = (int) 1 ;
29526 int arg5 = (int) 1 ;
29527 bool result;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 PyObject * obj2 = 0 ;
29531 PyObject * obj3 = 0 ;
29532 PyObject * obj4 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29539 if (SWIG_arg_fail(1)) SWIG_fail;
29540 {
29541 arg2 = (int)(SWIG_As_int(obj1));
29542 if (SWIG_arg_fail(2)) SWIG_fail;
29543 }
29544 {
29545 arg3 = (int)(SWIG_As_int(obj2));
29546 if (SWIG_arg_fail(3)) SWIG_fail;
29547 }
29548 if (obj3) {
29549 {
29550 arg4 = (int)(SWIG_As_int(obj3));
29551 if (SWIG_arg_fail(4)) SWIG_fail;
29552 }
29553 }
29554 if (obj4) {
29555 {
29556 arg5 = (int)(SWIG_As_int(obj4));
29557 if (SWIG_arg_fail(5)) SWIG_fail;
29558 }
29559 }
29560 {
29561 PyThreadState* __tstate = wxPyBeginAllowThreads();
29562 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29563
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 {
29568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29569 }
29570 return resultobj;
29571 fail:
29572 return NULL;
29573 }
29574
29575
29576 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29577 PyObject *resultobj;
29578 wxWindow *arg1 = (wxWindow *) 0 ;
29579 wxPoint *arg2 = 0 ;
29580 bool result;
29581 wxPoint temp2 ;
29582 PyObject * obj0 = 0 ;
29583 PyObject * obj1 = 0 ;
29584 char *kwnames[] = {
29585 (char *) "self",(char *) "pt", NULL
29586 };
29587
29588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29590 if (SWIG_arg_fail(1)) SWIG_fail;
29591 {
29592 arg2 = &temp2;
29593 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29594 }
29595 {
29596 PyThreadState* __tstate = wxPyBeginAllowThreads();
29597 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29598
29599 wxPyEndAllowThreads(__tstate);
29600 if (PyErr_Occurred()) SWIG_fail;
29601 }
29602 {
29603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29604 }
29605 return resultobj;
29606 fail:
29607 return NULL;
29608 }
29609
29610
29611 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29612 PyObject *resultobj;
29613 wxWindow *arg1 = (wxWindow *) 0 ;
29614 wxRect *arg2 = 0 ;
29615 bool result;
29616 wxRect temp2 ;
29617 PyObject * obj0 = 0 ;
29618 PyObject * obj1 = 0 ;
29619 char *kwnames[] = {
29620 (char *) "self",(char *) "rect", NULL
29621 };
29622
29623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29625 if (SWIG_arg_fail(1)) SWIG_fail;
29626 {
29627 arg2 = &temp2;
29628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29629 }
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29633
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 {
29638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29639 }
29640 return resultobj;
29641 fail:
29642 return NULL;
29643 }
29644
29645
29646 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29647 PyObject *resultobj;
29648 wxWindow *arg1 = (wxWindow *) 0 ;
29649 wxVisualAttributes result;
29650 PyObject * obj0 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 PyThreadState* __tstate = wxPyBeginAllowThreads();
29660 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29661
29662 wxPyEndAllowThreads(__tstate);
29663 if (PyErr_Occurred()) SWIG_fail;
29664 }
29665 {
29666 wxVisualAttributes * resultptr;
29667 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29669 }
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29677 PyObject *resultobj;
29678 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29679 wxVisualAttributes result;
29680 PyObject * obj0 = 0 ;
29681 char *kwnames[] = {
29682 (char *) "variant", NULL
29683 };
29684
29685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29686 if (obj0) {
29687 {
29688 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29689 if (SWIG_arg_fail(1)) SWIG_fail;
29690 }
29691 }
29692 {
29693 if (!wxPyCheckForApp()) SWIG_fail;
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29696
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 wxVisualAttributes * resultptr;
29702 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj;
29713 wxWindow *arg1 = (wxWindow *) 0 ;
29714 wxColour *arg2 = 0 ;
29715 bool result;
29716 wxColour temp2 ;
29717 PyObject * obj0 = 0 ;
29718 PyObject * obj1 = 0 ;
29719 char *kwnames[] = {
29720 (char *) "self",(char *) "colour", NULL
29721 };
29722
29723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29725 if (SWIG_arg_fail(1)) SWIG_fail;
29726 {
29727 arg2 = &temp2;
29728 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29729 }
29730 {
29731 PyThreadState* __tstate = wxPyBeginAllowThreads();
29732 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29733
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 {
29738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29739 }
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29747 PyObject *resultobj;
29748 wxWindow *arg1 = (wxWindow *) 0 ;
29749 wxColour *arg2 = 0 ;
29750 wxColour temp2 ;
29751 PyObject * obj0 = 0 ;
29752 PyObject * obj1 = 0 ;
29753 char *kwnames[] = {
29754 (char *) "self",(char *) "colour", NULL
29755 };
29756
29757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29759 if (SWIG_arg_fail(1)) SWIG_fail;
29760 {
29761 arg2 = &temp2;
29762 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29763 }
29764 {
29765 PyThreadState* __tstate = wxPyBeginAllowThreads();
29766 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29767
29768 wxPyEndAllowThreads(__tstate);
29769 if (PyErr_Occurred()) SWIG_fail;
29770 }
29771 Py_INCREF(Py_None); resultobj = Py_None;
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29779 PyObject *resultobj;
29780 wxWindow *arg1 = (wxWindow *) 0 ;
29781 wxColour *arg2 = 0 ;
29782 bool result;
29783 wxColour temp2 ;
29784 PyObject * obj0 = 0 ;
29785 PyObject * obj1 = 0 ;
29786 char *kwnames[] = {
29787 (char *) "self",(char *) "colour", NULL
29788 };
29789
29790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29792 if (SWIG_arg_fail(1)) SWIG_fail;
29793 {
29794 arg2 = &temp2;
29795 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29796 }
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29800
29801 wxPyEndAllowThreads(__tstate);
29802 if (PyErr_Occurred()) SWIG_fail;
29803 }
29804 {
29805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29806 }
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29814 PyObject *resultobj;
29815 wxWindow *arg1 = (wxWindow *) 0 ;
29816 wxColour *arg2 = 0 ;
29817 wxColour temp2 ;
29818 PyObject * obj0 = 0 ;
29819 PyObject * obj1 = 0 ;
29820 char *kwnames[] = {
29821 (char *) "self",(char *) "colour", NULL
29822 };
29823
29824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29826 if (SWIG_arg_fail(1)) SWIG_fail;
29827 {
29828 arg2 = &temp2;
29829 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29830 }
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29834
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 Py_INCREF(Py_None); resultobj = Py_None;
29839 return resultobj;
29840 fail:
29841 return NULL;
29842 }
29843
29844
29845 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29846 PyObject *resultobj;
29847 wxWindow *arg1 = (wxWindow *) 0 ;
29848 wxColour result;
29849 PyObject * obj0 = 0 ;
29850 char *kwnames[] = {
29851 (char *) "self", NULL
29852 };
29853
29854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29856 if (SWIG_arg_fail(1)) SWIG_fail;
29857 {
29858 PyThreadState* __tstate = wxPyBeginAllowThreads();
29859 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29860
29861 wxPyEndAllowThreads(__tstate);
29862 if (PyErr_Occurred()) SWIG_fail;
29863 }
29864 {
29865 wxColour * resultptr;
29866 resultptr = new wxColour((wxColour &)(result));
29867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 wxColour result;
29879 PyObject * obj0 = 0 ;
29880 char *kwnames[] = {
29881 (char *) "self", NULL
29882 };
29883
29884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29886 if (SWIG_arg_fail(1)) SWIG_fail;
29887 {
29888 PyThreadState* __tstate = wxPyBeginAllowThreads();
29889 result = ((wxWindow const *)arg1)->GetForegroundColour();
29890
29891 wxPyEndAllowThreads(__tstate);
29892 if (PyErr_Occurred()) SWIG_fail;
29893 }
29894 {
29895 wxColour * resultptr;
29896 resultptr = new wxColour((wxColour &)(result));
29897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29898 }
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29906 PyObject *resultobj;
29907 wxWindow *arg1 = (wxWindow *) 0 ;
29908 bool result;
29909 PyObject * obj0 = 0 ;
29910 char *kwnames[] = {
29911 (char *) "self", NULL
29912 };
29913
29914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29916 if (SWIG_arg_fail(1)) SWIG_fail;
29917 {
29918 PyThreadState* __tstate = wxPyBeginAllowThreads();
29919 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29920
29921 wxPyEndAllowThreads(__tstate);
29922 if (PyErr_Occurred()) SWIG_fail;
29923 }
29924 {
29925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29926 }
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29934 PyObject *resultobj;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 bool result;
29937 PyObject * obj0 = 0 ;
29938 char *kwnames[] = {
29939 (char *) "self", NULL
29940 };
29941
29942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29944 if (SWIG_arg_fail(1)) SWIG_fail;
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29948
29949 wxPyEndAllowThreads(__tstate);
29950 if (PyErr_Occurred()) SWIG_fail;
29951 }
29952 {
29953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29954 }
29955 return resultobj;
29956 fail:
29957 return NULL;
29958 }
29959
29960
29961 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29962 PyObject *resultobj;
29963 wxWindow *arg1 = (wxWindow *) 0 ;
29964 wxBackgroundStyle arg2 ;
29965 bool result;
29966 PyObject * obj0 = 0 ;
29967 PyObject * obj1 = 0 ;
29968 char *kwnames[] = {
29969 (char *) "self",(char *) "style", NULL
29970 };
29971
29972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29974 if (SWIG_arg_fail(1)) SWIG_fail;
29975 {
29976 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29977 if (SWIG_arg_fail(2)) SWIG_fail;
29978 }
29979 {
29980 PyThreadState* __tstate = wxPyBeginAllowThreads();
29981 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29982
29983 wxPyEndAllowThreads(__tstate);
29984 if (PyErr_Occurred()) SWIG_fail;
29985 }
29986 {
29987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29988 }
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29996 PyObject *resultobj;
29997 wxWindow *arg1 = (wxWindow *) 0 ;
29998 wxBackgroundStyle result;
29999 PyObject * obj0 = 0 ;
30000 char *kwnames[] = {
30001 (char *) "self", NULL
30002 };
30003
30004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30006 if (SWIG_arg_fail(1)) SWIG_fail;
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30010
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_From_int((result));
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj;
30023 wxWindow *arg1 = (wxWindow *) 0 ;
30024 bool result;
30025 PyObject * obj0 = 0 ;
30026 char *kwnames[] = {
30027 (char *) "self", NULL
30028 };
30029
30030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30032 if (SWIG_arg_fail(1)) SWIG_fail;
30033 {
30034 PyThreadState* __tstate = wxPyBeginAllowThreads();
30035 result = (bool)(arg1)->HasTransparentBackground();
30036
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 {
30041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30042 }
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 wxCursor *arg2 = 0 ;
30053 bool result;
30054 PyObject * obj0 = 0 ;
30055 PyObject * obj1 = 0 ;
30056 char *kwnames[] = {
30057 (char *) "self",(char *) "cursor", NULL
30058 };
30059
30060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30062 if (SWIG_arg_fail(1)) SWIG_fail;
30063 {
30064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 if (arg2 == NULL) {
30067 SWIG_null_ref("wxCursor");
30068 }
30069 if (SWIG_arg_fail(2)) SWIG_fail;
30070 }
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30074
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 {
30079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30080 }
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj;
30089 wxWindow *arg1 = (wxWindow *) 0 ;
30090 wxCursor result;
30091 PyObject * obj0 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 result = (arg1)->GetCursor();
30102
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 {
30107 wxCursor * resultptr;
30108 resultptr = new wxCursor((wxCursor &)(result));
30109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30110 }
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj;
30119 wxWindow *arg1 = (wxWindow *) 0 ;
30120 wxFont *arg2 = 0 ;
30121 bool result;
30122 PyObject * obj0 = 0 ;
30123 PyObject * obj1 = 0 ;
30124 char *kwnames[] = {
30125 (char *) "self",(char *) "font", NULL
30126 };
30127
30128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30130 if (SWIG_arg_fail(1)) SWIG_fail;
30131 {
30132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30133 if (SWIG_arg_fail(2)) SWIG_fail;
30134 if (arg2 == NULL) {
30135 SWIG_null_ref("wxFont");
30136 }
30137 if (SWIG_arg_fail(2)) SWIG_fail;
30138 }
30139 {
30140 PyThreadState* __tstate = wxPyBeginAllowThreads();
30141 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30142
30143 wxPyEndAllowThreads(__tstate);
30144 if (PyErr_Occurred()) SWIG_fail;
30145 }
30146 {
30147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30148 }
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 wxFont *arg2 = 0 ;
30159 PyObject * obj0 = 0 ;
30160 PyObject * obj1 = 0 ;
30161 char *kwnames[] = {
30162 (char *) "self",(char *) "font", NULL
30163 };
30164
30165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30167 if (SWIG_arg_fail(1)) SWIG_fail;
30168 {
30169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30170 if (SWIG_arg_fail(2)) SWIG_fail;
30171 if (arg2 == NULL) {
30172 SWIG_null_ref("wxFont");
30173 }
30174 if (SWIG_arg_fail(2)) SWIG_fail;
30175 }
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 (arg1)->SetOwnFont((wxFont const &)*arg2);
30179
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 Py_INCREF(Py_None); resultobj = Py_None;
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30191 PyObject *resultobj;
30192 wxWindow *arg1 = (wxWindow *) 0 ;
30193 wxFont result;
30194 PyObject * obj0 = 0 ;
30195 char *kwnames[] = {
30196 (char *) "self", NULL
30197 };
30198
30199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30201 if (SWIG_arg_fail(1)) SWIG_fail;
30202 {
30203 PyThreadState* __tstate = wxPyBeginAllowThreads();
30204 result = (arg1)->GetFont();
30205
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 {
30210 wxFont * resultptr;
30211 resultptr = new wxFont((wxFont &)(result));
30212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30213 }
30214 return resultobj;
30215 fail:
30216 return NULL;
30217 }
30218
30219
30220 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30221 PyObject *resultobj;
30222 wxWindow *arg1 = (wxWindow *) 0 ;
30223 wxCaret *arg2 = (wxCaret *) 0 ;
30224 PyObject * obj0 = 0 ;
30225 PyObject * obj1 = 0 ;
30226 char *kwnames[] = {
30227 (char *) "self",(char *) "caret", NULL
30228 };
30229
30230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30232 if (SWIG_arg_fail(1)) SWIG_fail;
30233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30234 if (SWIG_arg_fail(2)) SWIG_fail;
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 (arg1)->SetCaret(arg2);
30238
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 Py_INCREF(Py_None); resultobj = Py_None;
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30250 PyObject *resultobj;
30251 wxWindow *arg1 = (wxWindow *) 0 ;
30252 wxCaret *result;
30253 PyObject * obj0 = 0 ;
30254 char *kwnames[] = {
30255 (char *) "self", NULL
30256 };
30257
30258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30260 if (SWIG_arg_fail(1)) SWIG_fail;
30261 {
30262 PyThreadState* __tstate = wxPyBeginAllowThreads();
30263 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30264
30265 wxPyEndAllowThreads(__tstate);
30266 if (PyErr_Occurred()) SWIG_fail;
30267 }
30268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj;
30277 wxWindow *arg1 = (wxWindow *) 0 ;
30278 int result;
30279 PyObject * obj0 = 0 ;
30280 char *kwnames[] = {
30281 (char *) "self", NULL
30282 };
30283
30284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30286 if (SWIG_arg_fail(1)) SWIG_fail;
30287 {
30288 PyThreadState* __tstate = wxPyBeginAllowThreads();
30289 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30290
30291 wxPyEndAllowThreads(__tstate);
30292 if (PyErr_Occurred()) SWIG_fail;
30293 }
30294 {
30295 resultobj = SWIG_From_int((int)(result));
30296 }
30297 return resultobj;
30298 fail:
30299 return NULL;
30300 }
30301
30302
30303 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30304 PyObject *resultobj;
30305 wxWindow *arg1 = (wxWindow *) 0 ;
30306 int result;
30307 PyObject * obj0 = 0 ;
30308 char *kwnames[] = {
30309 (char *) "self", NULL
30310 };
30311
30312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30314 if (SWIG_arg_fail(1)) SWIG_fail;
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30318
30319 wxPyEndAllowThreads(__tstate);
30320 if (PyErr_Occurred()) SWIG_fail;
30321 }
30322 {
30323 resultobj = SWIG_From_int((int)(result));
30324 }
30325 return resultobj;
30326 fail:
30327 return NULL;
30328 }
30329
30330
30331 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30332 PyObject *resultobj;
30333 wxWindow *arg1 = (wxWindow *) 0 ;
30334 wxString *arg2 = 0 ;
30335 int *arg3 = (int *) 0 ;
30336 int *arg4 = (int *) 0 ;
30337 bool temp2 = false ;
30338 int temp3 ;
30339 int res3 = 0 ;
30340 int temp4 ;
30341 int res4 = 0 ;
30342 PyObject * obj0 = 0 ;
30343 PyObject * obj1 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self",(char *) "string", NULL
30346 };
30347
30348 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30349 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30352 if (SWIG_arg_fail(1)) SWIG_fail;
30353 {
30354 arg2 = wxString_in_helper(obj1);
30355 if (arg2 == NULL) SWIG_fail;
30356 temp2 = true;
30357 }
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30361
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 Py_INCREF(Py_None); resultobj = Py_None;
30366 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30367 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30368 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30369 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30370 {
30371 if (temp2)
30372 delete arg2;
30373 }
30374 return resultobj;
30375 fail:
30376 {
30377 if (temp2)
30378 delete arg2;
30379 }
30380 return NULL;
30381 }
30382
30383
30384 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30385 PyObject *resultobj;
30386 wxWindow *arg1 = (wxWindow *) 0 ;
30387 wxString *arg2 = 0 ;
30388 int *arg3 = (int *) 0 ;
30389 int *arg4 = (int *) 0 ;
30390 int *arg5 = (int *) 0 ;
30391 int *arg6 = (int *) 0 ;
30392 wxFont *arg7 = (wxFont *) NULL ;
30393 bool temp2 = false ;
30394 int temp3 ;
30395 int res3 = 0 ;
30396 int temp4 ;
30397 int res4 = 0 ;
30398 int temp5 ;
30399 int res5 = 0 ;
30400 int temp6 ;
30401 int res6 = 0 ;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 PyObject * obj2 = 0 ;
30405 char *kwnames[] = {
30406 (char *) "self",(char *) "string",(char *) "font", NULL
30407 };
30408
30409 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30410 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30411 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30412 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(1)) SWIG_fail;
30416 {
30417 arg2 = wxString_in_helper(obj1);
30418 if (arg2 == NULL) SWIG_fail;
30419 temp2 = true;
30420 }
30421 if (obj2) {
30422 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30423 if (SWIG_arg_fail(7)) SWIG_fail;
30424 }
30425 {
30426 PyThreadState* __tstate = wxPyBeginAllowThreads();
30427 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30428
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 Py_INCREF(Py_None); resultobj = Py_None;
30433 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30434 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30435 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30436 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30437 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30438 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30439 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30440 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30441 {
30442 if (temp2)
30443 delete arg2;
30444 }
30445 return resultobj;
30446 fail:
30447 {
30448 if (temp2)
30449 delete arg2;
30450 }
30451 return NULL;
30452 }
30453
30454
30455 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30456 PyObject *resultobj;
30457 wxWindow *arg1 = (wxWindow *) 0 ;
30458 int *arg2 = (int *) 0 ;
30459 int *arg3 = (int *) 0 ;
30460 int temp2 ;
30461 int res2 = 0 ;
30462 int temp3 ;
30463 int res3 = 0 ;
30464 PyObject * obj0 = 0 ;
30465 PyObject * obj1 = 0 ;
30466 PyObject * obj2 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self",(char *) "x",(char *) "y", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30473 if (SWIG_arg_fail(1)) SWIG_fail;
30474 {
30475 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30476 temp2 = SWIG_As_int(obj1);
30477 if (SWIG_arg_fail(2)) SWIG_fail;
30478 arg2 = &temp2;
30479 res2 = SWIG_NEWOBJ;
30480 }
30481 }
30482 {
30483 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30484 temp3 = SWIG_As_int(obj2);
30485 if (SWIG_arg_fail(3)) SWIG_fail;
30486 arg3 = &temp3;
30487 res3 = SWIG_NEWOBJ;
30488 }
30489 }
30490 {
30491 PyThreadState* __tstate = wxPyBeginAllowThreads();
30492 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30493
30494 wxPyEndAllowThreads(__tstate);
30495 if (PyErr_Occurred()) SWIG_fail;
30496 }
30497 Py_INCREF(Py_None); resultobj = Py_None;
30498 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30499 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30500 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30501 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30509 PyObject *resultobj;
30510 wxWindow *arg1 = (wxWindow *) 0 ;
30511 int *arg2 = (int *) 0 ;
30512 int *arg3 = (int *) 0 ;
30513 int temp2 ;
30514 int res2 = 0 ;
30515 int temp3 ;
30516 int res3 = 0 ;
30517 PyObject * obj0 = 0 ;
30518 PyObject * obj1 = 0 ;
30519 PyObject * obj2 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self",(char *) "x",(char *) "y", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30529 temp2 = SWIG_As_int(obj1);
30530 if (SWIG_arg_fail(2)) SWIG_fail;
30531 arg2 = &temp2;
30532 res2 = SWIG_NEWOBJ;
30533 }
30534 }
30535 {
30536 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30537 temp3 = SWIG_As_int(obj2);
30538 if (SWIG_arg_fail(3)) SWIG_fail;
30539 arg3 = &temp3;
30540 res3 = SWIG_NEWOBJ;
30541 }
30542 }
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30546
30547 wxPyEndAllowThreads(__tstate);
30548 if (PyErr_Occurred()) SWIG_fail;
30549 }
30550 Py_INCREF(Py_None); resultobj = Py_None;
30551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30552 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30554 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30562 PyObject *resultobj;
30563 wxWindow *arg1 = (wxWindow *) 0 ;
30564 wxPoint *arg2 = 0 ;
30565 wxPoint result;
30566 wxPoint temp2 ;
30567 PyObject * obj0 = 0 ;
30568 PyObject * obj1 = 0 ;
30569 char *kwnames[] = {
30570 (char *) "self",(char *) "pt", NULL
30571 };
30572
30573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30575 if (SWIG_arg_fail(1)) SWIG_fail;
30576 {
30577 arg2 = &temp2;
30578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30579 }
30580 {
30581 PyThreadState* __tstate = wxPyBeginAllowThreads();
30582 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30583
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 {
30588 wxPoint * resultptr;
30589 resultptr = new wxPoint((wxPoint &)(result));
30590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30591 }
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj;
30600 wxWindow *arg1 = (wxWindow *) 0 ;
30601 wxPoint *arg2 = 0 ;
30602 wxPoint result;
30603 wxPoint temp2 ;
30604 PyObject * obj0 = 0 ;
30605 PyObject * obj1 = 0 ;
30606 char *kwnames[] = {
30607 (char *) "self",(char *) "pt", NULL
30608 };
30609
30610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30612 if (SWIG_arg_fail(1)) SWIG_fail;
30613 {
30614 arg2 = &temp2;
30615 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30616 }
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30620
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 {
30625 wxPoint * resultptr;
30626 resultptr = new wxPoint((wxPoint &)(result));
30627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30628 }
30629 return resultobj;
30630 fail:
30631 return NULL;
30632 }
30633
30634
30635 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30636 PyObject *resultobj;
30637 wxWindow *arg1 = (wxWindow *) 0 ;
30638 int arg2 ;
30639 int arg3 ;
30640 wxHitTest result;
30641 PyObject * obj0 = 0 ;
30642 PyObject * obj1 = 0 ;
30643 PyObject * obj2 = 0 ;
30644 char *kwnames[] = {
30645 (char *) "self",(char *) "x",(char *) "y", NULL
30646 };
30647
30648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30650 if (SWIG_arg_fail(1)) SWIG_fail;
30651 {
30652 arg2 = (int)(SWIG_As_int(obj1));
30653 if (SWIG_arg_fail(2)) SWIG_fail;
30654 }
30655 {
30656 arg3 = (int)(SWIG_As_int(obj2));
30657 if (SWIG_arg_fail(3)) SWIG_fail;
30658 }
30659 {
30660 PyThreadState* __tstate = wxPyBeginAllowThreads();
30661 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30662
30663 wxPyEndAllowThreads(__tstate);
30664 if (PyErr_Occurred()) SWIG_fail;
30665 }
30666 resultobj = SWIG_From_int((result));
30667 return resultobj;
30668 fail:
30669 return NULL;
30670 }
30671
30672
30673 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30674 PyObject *resultobj;
30675 wxWindow *arg1 = (wxWindow *) 0 ;
30676 wxPoint *arg2 = 0 ;
30677 wxHitTest result;
30678 wxPoint temp2 ;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self",(char *) "pt", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 {
30689 arg2 = &temp2;
30690 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30691 }
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30695
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_From_int((result));
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30707 PyObject *resultobj;
30708 wxWindow *arg1 = (wxWindow *) 0 ;
30709 long arg2 ;
30710 wxBorder result;
30711 PyObject * obj0 = 0 ;
30712 PyObject * obj1 = 0 ;
30713
30714 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30716 if (SWIG_arg_fail(1)) SWIG_fail;
30717 {
30718 arg2 = (long)(SWIG_As_long(obj1));
30719 if (SWIG_arg_fail(2)) SWIG_fail;
30720 }
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30724
30725 wxPyEndAllowThreads(__tstate);
30726 if (PyErr_Occurred()) SWIG_fail;
30727 }
30728 resultobj = SWIG_From_int((result));
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30736 PyObject *resultobj;
30737 wxWindow *arg1 = (wxWindow *) 0 ;
30738 wxBorder result;
30739 PyObject * obj0 = 0 ;
30740
30741 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30743 if (SWIG_arg_fail(1)) SWIG_fail;
30744 {
30745 PyThreadState* __tstate = wxPyBeginAllowThreads();
30746 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30747
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 resultobj = SWIG_From_int((result));
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30759 int argc;
30760 PyObject *argv[3];
30761 int ii;
30762
30763 argc = PyObject_Length(args);
30764 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30765 argv[ii] = PyTuple_GetItem(args,ii);
30766 }
30767 if (argc == 1) {
30768 int _v;
30769 {
30770 void *ptr;
30771 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30772 _v = 0;
30773 PyErr_Clear();
30774 } else {
30775 _v = 1;
30776 }
30777 }
30778 if (_v) {
30779 return _wrap_Window_GetBorder__SWIG_1(self,args);
30780 }
30781 }
30782 if (argc == 2) {
30783 int _v;
30784 {
30785 void *ptr;
30786 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30787 _v = 0;
30788 PyErr_Clear();
30789 } else {
30790 _v = 1;
30791 }
30792 }
30793 if (_v) {
30794 _v = SWIG_Check_long(argv[1]);
30795 if (_v) {
30796 return _wrap_Window_GetBorder__SWIG_0(self,args);
30797 }
30798 }
30799 }
30800
30801 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30802 return NULL;
30803 }
30804
30805
30806 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30807 PyObject *resultobj;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 long arg2 = (long) wxUPDATE_UI_NONE ;
30810 PyObject * obj0 = 0 ;
30811 PyObject * obj1 = 0 ;
30812 char *kwnames[] = {
30813 (char *) "self",(char *) "flags", NULL
30814 };
30815
30816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30818 if (SWIG_arg_fail(1)) SWIG_fail;
30819 if (obj1) {
30820 {
30821 arg2 = (long)(SWIG_As_long(obj1));
30822 if (SWIG_arg_fail(2)) SWIG_fail;
30823 }
30824 }
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 (arg1)->UpdateWindowUI(arg2);
30828
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 Py_INCREF(Py_None); resultobj = Py_None;
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj;
30841 wxWindow *arg1 = (wxWindow *) 0 ;
30842 wxMenu *arg2 = (wxMenu *) 0 ;
30843 int arg3 = (int) -1 ;
30844 int arg4 = (int) -1 ;
30845 bool result;
30846 PyObject * obj0 = 0 ;
30847 PyObject * obj1 = 0 ;
30848 PyObject * obj2 = 0 ;
30849 PyObject * obj3 = 0 ;
30850 char *kwnames[] = {
30851 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30852 };
30853
30854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30856 if (SWIG_arg_fail(1)) SWIG_fail;
30857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30858 if (SWIG_arg_fail(2)) SWIG_fail;
30859 if (obj2) {
30860 {
30861 arg3 = (int)(SWIG_As_int(obj2));
30862 if (SWIG_arg_fail(3)) SWIG_fail;
30863 }
30864 }
30865 if (obj3) {
30866 {
30867 arg4 = (int)(SWIG_As_int(obj3));
30868 if (SWIG_arg_fail(4)) SWIG_fail;
30869 }
30870 }
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30874
30875 wxPyEndAllowThreads(__tstate);
30876 if (PyErr_Occurred()) SWIG_fail;
30877 }
30878 {
30879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30880 }
30881 return resultobj;
30882 fail:
30883 return NULL;
30884 }
30885
30886
30887 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30888 PyObject *resultobj;
30889 wxWindow *arg1 = (wxWindow *) 0 ;
30890 wxMenu *arg2 = (wxMenu *) 0 ;
30891 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30892 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30893 bool result;
30894 wxPoint temp3 ;
30895 PyObject * obj0 = 0 ;
30896 PyObject * obj1 = 0 ;
30897 PyObject * obj2 = 0 ;
30898 char *kwnames[] = {
30899 (char *) "self",(char *) "menu",(char *) "pos", NULL
30900 };
30901
30902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30904 if (SWIG_arg_fail(1)) SWIG_fail;
30905 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30906 if (SWIG_arg_fail(2)) SWIG_fail;
30907 if (obj2) {
30908 {
30909 arg3 = &temp3;
30910 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30911 }
30912 }
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 {
30921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30922 }
30923 return resultobj;
30924 fail:
30925 return NULL;
30926 }
30927
30928
30929 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30930 PyObject *resultobj;
30931 wxWindow *arg1 = (wxWindow *) 0 ;
30932 long result;
30933 PyObject * obj0 = 0 ;
30934 char *kwnames[] = {
30935 (char *) "self", NULL
30936 };
30937
30938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30940 if (SWIG_arg_fail(1)) SWIG_fail;
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 result = (long)wxWindow_GetHandle(arg1);
30944
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 {
30949 resultobj = SWIG_From_long((long)(result));
30950 }
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30958 PyObject *resultobj;
30959 wxWindow *arg1 = (wxWindow *) 0 ;
30960 long arg2 ;
30961 PyObject * obj0 = 0 ;
30962 PyObject * obj1 = 0 ;
30963 char *kwnames[] = {
30964 (char *) "self",(char *) "handle", NULL
30965 };
30966
30967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(1)) SWIG_fail;
30970 {
30971 arg2 = (long)(SWIG_As_long(obj1));
30972 if (SWIG_arg_fail(2)) SWIG_fail;
30973 }
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 wxWindow_AssociateHandle(arg1,arg2);
30977
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 Py_INCREF(Py_None); resultobj = Py_None;
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj;
30990 wxWindow *arg1 = (wxWindow *) 0 ;
30991 PyObject * obj0 = 0 ;
30992 char *kwnames[] = {
30993 (char *) "self", NULL
30994 };
30995
30996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30998 if (SWIG_arg_fail(1)) SWIG_fail;
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 (arg1)->DissociateHandle();
31002
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 Py_INCREF(Py_None); resultobj = Py_None;
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31014 PyObject *resultobj;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 int arg2 ;
31017 bool result;
31018 PyObject * obj0 = 0 ;
31019 PyObject * obj1 = 0 ;
31020 char *kwnames[] = {
31021 (char *) "self",(char *) "orient", NULL
31022 };
31023
31024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31026 if (SWIG_arg_fail(1)) SWIG_fail;
31027 {
31028 arg2 = (int)(SWIG_As_int(obj1));
31029 if (SWIG_arg_fail(2)) SWIG_fail;
31030 }
31031 {
31032 PyThreadState* __tstate = wxPyBeginAllowThreads();
31033 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31034
31035 wxPyEndAllowThreads(__tstate);
31036 if (PyErr_Occurred()) SWIG_fail;
31037 }
31038 {
31039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31040 }
31041 return resultobj;
31042 fail:
31043 return NULL;
31044 }
31045
31046
31047 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31048 PyObject *resultobj;
31049 wxWindow *arg1 = (wxWindow *) 0 ;
31050 int arg2 ;
31051 int arg3 ;
31052 int arg4 ;
31053 int arg5 ;
31054 bool arg6 = (bool) true ;
31055 PyObject * obj0 = 0 ;
31056 PyObject * obj1 = 0 ;
31057 PyObject * obj2 = 0 ;
31058 PyObject * obj3 = 0 ;
31059 PyObject * obj4 = 0 ;
31060 PyObject * obj5 = 0 ;
31061 char *kwnames[] = {
31062 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31063 };
31064
31065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31067 if (SWIG_arg_fail(1)) SWIG_fail;
31068 {
31069 arg2 = (int)(SWIG_As_int(obj1));
31070 if (SWIG_arg_fail(2)) SWIG_fail;
31071 }
31072 {
31073 arg3 = (int)(SWIG_As_int(obj2));
31074 if (SWIG_arg_fail(3)) SWIG_fail;
31075 }
31076 {
31077 arg4 = (int)(SWIG_As_int(obj3));
31078 if (SWIG_arg_fail(4)) SWIG_fail;
31079 }
31080 {
31081 arg5 = (int)(SWIG_As_int(obj4));
31082 if (SWIG_arg_fail(5)) SWIG_fail;
31083 }
31084 if (obj5) {
31085 {
31086 arg6 = (bool)(SWIG_As_bool(obj5));
31087 if (SWIG_arg_fail(6)) SWIG_fail;
31088 }
31089 }
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31093
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 Py_INCREF(Py_None); resultobj = Py_None;
31098 return resultobj;
31099 fail:
31100 return NULL;
31101 }
31102
31103
31104 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31105 PyObject *resultobj;
31106 wxWindow *arg1 = (wxWindow *) 0 ;
31107 int arg2 ;
31108 int arg3 ;
31109 bool arg4 = (bool) true ;
31110 PyObject * obj0 = 0 ;
31111 PyObject * obj1 = 0 ;
31112 PyObject * obj2 = 0 ;
31113 PyObject * obj3 = 0 ;
31114 char *kwnames[] = {
31115 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31116 };
31117
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31120 if (SWIG_arg_fail(1)) SWIG_fail;
31121 {
31122 arg2 = (int)(SWIG_As_int(obj1));
31123 if (SWIG_arg_fail(2)) SWIG_fail;
31124 }
31125 {
31126 arg3 = (int)(SWIG_As_int(obj2));
31127 if (SWIG_arg_fail(3)) SWIG_fail;
31128 }
31129 if (obj3) {
31130 {
31131 arg4 = (bool)(SWIG_As_bool(obj3));
31132 if (SWIG_arg_fail(4)) SWIG_fail;
31133 }
31134 }
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 (arg1)->SetScrollPos(arg2,arg3,arg4);
31138
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 Py_INCREF(Py_None); resultobj = Py_None;
31143 return resultobj;
31144 fail:
31145 return NULL;
31146 }
31147
31148
31149 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31150 PyObject *resultobj;
31151 wxWindow *arg1 = (wxWindow *) 0 ;
31152 int arg2 ;
31153 int result;
31154 PyObject * obj0 = 0 ;
31155 PyObject * obj1 = 0 ;
31156 char *kwnames[] = {
31157 (char *) "self",(char *) "orientation", NULL
31158 };
31159
31160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31162 if (SWIG_arg_fail(1)) SWIG_fail;
31163 {
31164 arg2 = (int)(SWIG_As_int(obj1));
31165 if (SWIG_arg_fail(2)) SWIG_fail;
31166 }
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 {
31175 resultobj = SWIG_From_int((int)(result));
31176 }
31177 return resultobj;
31178 fail:
31179 return NULL;
31180 }
31181
31182
31183 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31184 PyObject *resultobj;
31185 wxWindow *arg1 = (wxWindow *) 0 ;
31186 int arg2 ;
31187 int result;
31188 PyObject * obj0 = 0 ;
31189 PyObject * obj1 = 0 ;
31190 char *kwnames[] = {
31191 (char *) "self",(char *) "orientation", NULL
31192 };
31193
31194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31196 if (SWIG_arg_fail(1)) SWIG_fail;
31197 {
31198 arg2 = (int)(SWIG_As_int(obj1));
31199 if (SWIG_arg_fail(2)) SWIG_fail;
31200 }
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31204
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 {
31209 resultobj = SWIG_From_int((int)(result));
31210 }
31211 return resultobj;
31212 fail:
31213 return NULL;
31214 }
31215
31216
31217 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31218 PyObject *resultobj;
31219 wxWindow *arg1 = (wxWindow *) 0 ;
31220 int arg2 ;
31221 int result;
31222 PyObject * obj0 = 0 ;
31223 PyObject * obj1 = 0 ;
31224 char *kwnames[] = {
31225 (char *) "self",(char *) "orientation", NULL
31226 };
31227
31228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31230 if (SWIG_arg_fail(1)) SWIG_fail;
31231 {
31232 arg2 = (int)(SWIG_As_int(obj1));
31233 if (SWIG_arg_fail(2)) SWIG_fail;
31234 }
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31238
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 {
31243 resultobj = SWIG_From_int((int)(result));
31244 }
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj;
31253 wxWindow *arg1 = (wxWindow *) 0 ;
31254 int arg2 ;
31255 int arg3 ;
31256 wxRect *arg4 = (wxRect *) NULL ;
31257 PyObject * obj0 = 0 ;
31258 PyObject * obj1 = 0 ;
31259 PyObject * obj2 = 0 ;
31260 PyObject * obj3 = 0 ;
31261 char *kwnames[] = {
31262 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31263 };
31264
31265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31267 if (SWIG_arg_fail(1)) SWIG_fail;
31268 {
31269 arg2 = (int)(SWIG_As_int(obj1));
31270 if (SWIG_arg_fail(2)) SWIG_fail;
31271 }
31272 {
31273 arg3 = (int)(SWIG_As_int(obj2));
31274 if (SWIG_arg_fail(3)) SWIG_fail;
31275 }
31276 if (obj3) {
31277 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31278 if (SWIG_arg_fail(4)) SWIG_fail;
31279 }
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31283
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 Py_INCREF(Py_None); resultobj = Py_None;
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31295 PyObject *resultobj;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 int arg2 ;
31298 bool result;
31299 PyObject * obj0 = 0 ;
31300 PyObject * obj1 = 0 ;
31301 char *kwnames[] = {
31302 (char *) "self",(char *) "lines", NULL
31303 };
31304
31305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31307 if (SWIG_arg_fail(1)) SWIG_fail;
31308 {
31309 arg2 = (int)(SWIG_As_int(obj1));
31310 if (SWIG_arg_fail(2)) SWIG_fail;
31311 }
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 result = (bool)(arg1)->ScrollLines(arg2);
31315
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 {
31320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31321 }
31322 return resultobj;
31323 fail:
31324 return NULL;
31325 }
31326
31327
31328 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31329 PyObject *resultobj;
31330 wxWindow *arg1 = (wxWindow *) 0 ;
31331 int arg2 ;
31332 bool result;
31333 PyObject * obj0 = 0 ;
31334 PyObject * obj1 = 0 ;
31335 char *kwnames[] = {
31336 (char *) "self",(char *) "pages", NULL
31337 };
31338
31339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31341 if (SWIG_arg_fail(1)) SWIG_fail;
31342 {
31343 arg2 = (int)(SWIG_As_int(obj1));
31344 if (SWIG_arg_fail(2)) SWIG_fail;
31345 }
31346 {
31347 PyThreadState* __tstate = wxPyBeginAllowThreads();
31348 result = (bool)(arg1)->ScrollPages(arg2);
31349
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 {
31354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31355 }
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31363 PyObject *resultobj;
31364 wxWindow *arg1 = (wxWindow *) 0 ;
31365 bool result;
31366 PyObject * obj0 = 0 ;
31367 char *kwnames[] = {
31368 (char *) "self", NULL
31369 };
31370
31371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31373 if (SWIG_arg_fail(1)) SWIG_fail;
31374 {
31375 PyThreadState* __tstate = wxPyBeginAllowThreads();
31376 result = (bool)(arg1)->LineUp();
31377
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 {
31382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31383 }
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31391 PyObject *resultobj;
31392 wxWindow *arg1 = (wxWindow *) 0 ;
31393 bool result;
31394 PyObject * obj0 = 0 ;
31395 char *kwnames[] = {
31396 (char *) "self", NULL
31397 };
31398
31399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31401 if (SWIG_arg_fail(1)) SWIG_fail;
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (bool)(arg1)->LineDown();
31405
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 {
31410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31411 }
31412 return resultobj;
31413 fail:
31414 return NULL;
31415 }
31416
31417
31418 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj;
31420 wxWindow *arg1 = (wxWindow *) 0 ;
31421 bool result;
31422 PyObject * obj0 = 0 ;
31423 char *kwnames[] = {
31424 (char *) "self", NULL
31425 };
31426
31427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31429 if (SWIG_arg_fail(1)) SWIG_fail;
31430 {
31431 PyThreadState* __tstate = wxPyBeginAllowThreads();
31432 result = (bool)(arg1)->PageUp();
31433
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 {
31438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31439 }
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj;
31448 wxWindow *arg1 = (wxWindow *) 0 ;
31449 bool result;
31450 PyObject * obj0 = 0 ;
31451 char *kwnames[] = {
31452 (char *) "self", NULL
31453 };
31454
31455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31457 if (SWIG_arg_fail(1)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (bool)(arg1)->PageDown();
31461
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31475 PyObject *resultobj;
31476 wxWindow *arg1 = (wxWindow *) 0 ;
31477 wxString *arg2 = 0 ;
31478 bool temp2 = false ;
31479 PyObject * obj0 = 0 ;
31480 PyObject * obj1 = 0 ;
31481 char *kwnames[] = {
31482 (char *) "self",(char *) "text", NULL
31483 };
31484
31485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31487 if (SWIG_arg_fail(1)) SWIG_fail;
31488 {
31489 arg2 = wxString_in_helper(obj1);
31490 if (arg2 == NULL) SWIG_fail;
31491 temp2 = true;
31492 }
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 (arg1)->SetHelpText((wxString const &)*arg2);
31496
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 Py_INCREF(Py_None); resultobj = Py_None;
31501 {
31502 if (temp2)
31503 delete arg2;
31504 }
31505 return resultobj;
31506 fail:
31507 {
31508 if (temp2)
31509 delete arg2;
31510 }
31511 return NULL;
31512 }
31513
31514
31515 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31516 PyObject *resultobj;
31517 wxWindow *arg1 = (wxWindow *) 0 ;
31518 wxString *arg2 = 0 ;
31519 bool temp2 = false ;
31520 PyObject * obj0 = 0 ;
31521 PyObject * obj1 = 0 ;
31522 char *kwnames[] = {
31523 (char *) "self",(char *) "text", NULL
31524 };
31525
31526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31528 if (SWIG_arg_fail(1)) SWIG_fail;
31529 {
31530 arg2 = wxString_in_helper(obj1);
31531 if (arg2 == NULL) SWIG_fail;
31532 temp2 = true;
31533 }
31534 {
31535 PyThreadState* __tstate = wxPyBeginAllowThreads();
31536 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31537
31538 wxPyEndAllowThreads(__tstate);
31539 if (PyErr_Occurred()) SWIG_fail;
31540 }
31541 Py_INCREF(Py_None); resultobj = Py_None;
31542 {
31543 if (temp2)
31544 delete arg2;
31545 }
31546 return resultobj;
31547 fail:
31548 {
31549 if (temp2)
31550 delete arg2;
31551 }
31552 return NULL;
31553 }
31554
31555
31556 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31557 PyObject *resultobj;
31558 wxWindow *arg1 = (wxWindow *) 0 ;
31559 wxString result;
31560 PyObject * obj0 = 0 ;
31561 char *kwnames[] = {
31562 (char *) "self", NULL
31563 };
31564
31565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31567 if (SWIG_arg_fail(1)) SWIG_fail;
31568 {
31569 PyThreadState* __tstate = wxPyBeginAllowThreads();
31570 result = ((wxWindow const *)arg1)->GetHelpText();
31571
31572 wxPyEndAllowThreads(__tstate);
31573 if (PyErr_Occurred()) SWIG_fail;
31574 }
31575 {
31576 #if wxUSE_UNICODE
31577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31578 #else
31579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31580 #endif
31581 }
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31589 PyObject *resultobj;
31590 wxWindow *arg1 = (wxWindow *) 0 ;
31591 wxString *arg2 = 0 ;
31592 bool temp2 = false ;
31593 PyObject * obj0 = 0 ;
31594 PyObject * obj1 = 0 ;
31595 char *kwnames[] = {
31596 (char *) "self",(char *) "tip", NULL
31597 };
31598
31599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31601 if (SWIG_arg_fail(1)) SWIG_fail;
31602 {
31603 arg2 = wxString_in_helper(obj1);
31604 if (arg2 == NULL) SWIG_fail;
31605 temp2 = true;
31606 }
31607 {
31608 PyThreadState* __tstate = wxPyBeginAllowThreads();
31609 (arg1)->SetToolTip((wxString const &)*arg2);
31610
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 Py_INCREF(Py_None); resultobj = Py_None;
31615 {
31616 if (temp2)
31617 delete arg2;
31618 }
31619 return resultobj;
31620 fail:
31621 {
31622 if (temp2)
31623 delete arg2;
31624 }
31625 return NULL;
31626 }
31627
31628
31629 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31630 PyObject *resultobj;
31631 wxWindow *arg1 = (wxWindow *) 0 ;
31632 wxToolTip *arg2 = (wxToolTip *) 0 ;
31633 PyObject * obj0 = 0 ;
31634 PyObject * obj1 = 0 ;
31635 char *kwnames[] = {
31636 (char *) "self",(char *) "tip", NULL
31637 };
31638
31639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31641 if (SWIG_arg_fail(1)) SWIG_fail;
31642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31643 if (SWIG_arg_fail(2)) SWIG_fail;
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 (arg1)->SetToolTip(arg2);
31647
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 Py_INCREF(Py_None); resultobj = Py_None;
31652 return resultobj;
31653 fail:
31654 return NULL;
31655 }
31656
31657
31658 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31659 PyObject *resultobj;
31660 wxWindow *arg1 = (wxWindow *) 0 ;
31661 wxToolTip *result;
31662 PyObject * obj0 = 0 ;
31663 char *kwnames[] = {
31664 (char *) "self", NULL
31665 };
31666
31667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31669 if (SWIG_arg_fail(1)) SWIG_fail;
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31673
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 {
31678 resultobj = wxPyMake_wxObject(result, 0);
31679 }
31680 return resultobj;
31681 fail:
31682 return NULL;
31683 }
31684
31685
31686 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31687 PyObject *resultobj;
31688 wxWindow *arg1 = (wxWindow *) 0 ;
31689 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31690 PyObject * obj0 = 0 ;
31691 PyObject * obj1 = 0 ;
31692 char *kwnames[] = {
31693 (char *) "self",(char *) "dropTarget", NULL
31694 };
31695
31696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31698 if (SWIG_arg_fail(1)) SWIG_fail;
31699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31700 if (SWIG_arg_fail(2)) SWIG_fail;
31701 {
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 (arg1)->SetDropTarget(arg2);
31704
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 Py_INCREF(Py_None); resultobj = Py_None;
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 wxPyDropTarget *result;
31719 PyObject * obj0 = 0 ;
31720 char *kwnames[] = {
31721 (char *) "self", NULL
31722 };
31723
31724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31726 if (SWIG_arg_fail(1)) SWIG_fail;
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31730
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31742 PyObject *resultobj;
31743 wxWindow *arg1 = (wxWindow *) 0 ;
31744 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31745 PyObject * obj0 = 0 ;
31746 PyObject * obj1 = 0 ;
31747 char *kwnames[] = {
31748 (char *) "self",(char *) "constraints", NULL
31749 };
31750
31751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31753 if (SWIG_arg_fail(1)) SWIG_fail;
31754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31755 if (SWIG_arg_fail(2)) SWIG_fail;
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 (arg1)->SetConstraints(arg2);
31759
31760 wxPyEndAllowThreads(__tstate);
31761 if (PyErr_Occurred()) SWIG_fail;
31762 }
31763 Py_INCREF(Py_None); resultobj = Py_None;
31764 return resultobj;
31765 fail:
31766 return NULL;
31767 }
31768
31769
31770 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31771 PyObject *resultobj;
31772 wxWindow *arg1 = (wxWindow *) 0 ;
31773 wxLayoutConstraints *result;
31774 PyObject * obj0 = 0 ;
31775 char *kwnames[] = {
31776 (char *) "self", NULL
31777 };
31778
31779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31781 if (SWIG_arg_fail(1)) SWIG_fail;
31782 {
31783 PyThreadState* __tstate = wxPyBeginAllowThreads();
31784 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31785
31786 wxPyEndAllowThreads(__tstate);
31787 if (PyErr_Occurred()) SWIG_fail;
31788 }
31789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31790 return resultobj;
31791 fail:
31792 return NULL;
31793 }
31794
31795
31796 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31797 PyObject *resultobj;
31798 wxWindow *arg1 = (wxWindow *) 0 ;
31799 bool arg2 ;
31800 PyObject * obj0 = 0 ;
31801 PyObject * obj1 = 0 ;
31802 char *kwnames[] = {
31803 (char *) "self",(char *) "autoLayout", NULL
31804 };
31805
31806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31808 if (SWIG_arg_fail(1)) SWIG_fail;
31809 {
31810 arg2 = (bool)(SWIG_As_bool(obj1));
31811 if (SWIG_arg_fail(2)) SWIG_fail;
31812 }
31813 {
31814 PyThreadState* __tstate = wxPyBeginAllowThreads();
31815 (arg1)->SetAutoLayout(arg2);
31816
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 Py_INCREF(Py_None); resultobj = Py_None;
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31828 PyObject *resultobj;
31829 wxWindow *arg1 = (wxWindow *) 0 ;
31830 bool result;
31831 PyObject * obj0 = 0 ;
31832 char *kwnames[] = {
31833 (char *) "self", NULL
31834 };
31835
31836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31838 if (SWIG_arg_fail(1)) SWIG_fail;
31839 {
31840 PyThreadState* __tstate = wxPyBeginAllowThreads();
31841 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31842
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 {
31847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31848 }
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj;
31857 wxWindow *arg1 = (wxWindow *) 0 ;
31858 bool result;
31859 PyObject * obj0 = 0 ;
31860 char *kwnames[] = {
31861 (char *) "self", NULL
31862 };
31863
31864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31866 if (SWIG_arg_fail(1)) SWIG_fail;
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (bool)(arg1)->Layout();
31870
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 {
31875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31876 }
31877 return resultobj;
31878 fail:
31879 return NULL;
31880 }
31881
31882
31883 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31884 PyObject *resultobj;
31885 wxWindow *arg1 = (wxWindow *) 0 ;
31886 wxSizer *arg2 = (wxSizer *) 0 ;
31887 bool arg3 = (bool) true ;
31888 PyObject * obj0 = 0 ;
31889 PyObject * obj1 = 0 ;
31890 PyObject * obj2 = 0 ;
31891 char *kwnames[] = {
31892 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31893 };
31894
31895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31897 if (SWIG_arg_fail(1)) SWIG_fail;
31898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31899 if (SWIG_arg_fail(2)) SWIG_fail;
31900 if (obj2) {
31901 {
31902 arg3 = (bool)(SWIG_As_bool(obj2));
31903 if (SWIG_arg_fail(3)) SWIG_fail;
31904 }
31905 }
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 (arg1)->SetSizer(arg2,arg3);
31909
31910 wxPyEndAllowThreads(__tstate);
31911 if (PyErr_Occurred()) SWIG_fail;
31912 }
31913 Py_INCREF(Py_None); resultobj = Py_None;
31914 return resultobj;
31915 fail:
31916 return NULL;
31917 }
31918
31919
31920 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31921 PyObject *resultobj;
31922 wxWindow *arg1 = (wxWindow *) 0 ;
31923 wxSizer *arg2 = (wxSizer *) 0 ;
31924 bool arg3 = (bool) true ;
31925 PyObject * obj0 = 0 ;
31926 PyObject * obj1 = 0 ;
31927 PyObject * obj2 = 0 ;
31928 char *kwnames[] = {
31929 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31930 };
31931
31932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31934 if (SWIG_arg_fail(1)) SWIG_fail;
31935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31936 if (SWIG_arg_fail(2)) SWIG_fail;
31937 if (obj2) {
31938 {
31939 arg3 = (bool)(SWIG_As_bool(obj2));
31940 if (SWIG_arg_fail(3)) SWIG_fail;
31941 }
31942 }
31943 {
31944 PyThreadState* __tstate = wxPyBeginAllowThreads();
31945 (arg1)->SetSizerAndFit(arg2,arg3);
31946
31947 wxPyEndAllowThreads(__tstate);
31948 if (PyErr_Occurred()) SWIG_fail;
31949 }
31950 Py_INCREF(Py_None); resultobj = Py_None;
31951 return resultobj;
31952 fail:
31953 return NULL;
31954 }
31955
31956
31957 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31958 PyObject *resultobj;
31959 wxWindow *arg1 = (wxWindow *) 0 ;
31960 wxSizer *result;
31961 PyObject * obj0 = 0 ;
31962 char *kwnames[] = {
31963 (char *) "self", NULL
31964 };
31965
31966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31968 if (SWIG_arg_fail(1)) SWIG_fail;
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31972
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 {
31977 resultobj = wxPyMake_wxObject(result, 0);
31978 }
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31986 PyObject *resultobj;
31987 wxWindow *arg1 = (wxWindow *) 0 ;
31988 wxSizer *arg2 = (wxSizer *) 0 ;
31989 PyObject * obj0 = 0 ;
31990 PyObject * obj1 = 0 ;
31991 char *kwnames[] = {
31992 (char *) "self",(char *) "sizer", NULL
31993 };
31994
31995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31997 if (SWIG_arg_fail(1)) SWIG_fail;
31998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31999 if (SWIG_arg_fail(2)) SWIG_fail;
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 (arg1)->SetContainingSizer(arg2);
32003
32004 wxPyEndAllowThreads(__tstate);
32005 if (PyErr_Occurred()) SWIG_fail;
32006 }
32007 Py_INCREF(Py_None); resultobj = Py_None;
32008 return resultobj;
32009 fail:
32010 return NULL;
32011 }
32012
32013
32014 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32015 PyObject *resultobj;
32016 wxWindow *arg1 = (wxWindow *) 0 ;
32017 wxSizer *result;
32018 PyObject * obj0 = 0 ;
32019 char *kwnames[] = {
32020 (char *) "self", NULL
32021 };
32022
32023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32025 if (SWIG_arg_fail(1)) SWIG_fail;
32026 {
32027 PyThreadState* __tstate = wxPyBeginAllowThreads();
32028 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32029
32030 wxPyEndAllowThreads(__tstate);
32031 if (PyErr_Occurred()) SWIG_fail;
32032 }
32033 {
32034 resultobj = wxPyMake_wxObject(result, 0);
32035 }
32036 return resultobj;
32037 fail:
32038 return NULL;
32039 }
32040
32041
32042 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32043 PyObject *resultobj;
32044 wxWindow *arg1 = (wxWindow *) 0 ;
32045 PyObject * obj0 = 0 ;
32046 char *kwnames[] = {
32047 (char *) "self", NULL
32048 };
32049
32050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32052 if (SWIG_arg_fail(1)) SWIG_fail;
32053 {
32054 PyThreadState* __tstate = wxPyBeginAllowThreads();
32055 (arg1)->InheritAttributes();
32056
32057 wxPyEndAllowThreads(__tstate);
32058 if (PyErr_Occurred()) SWIG_fail;
32059 }
32060 Py_INCREF(Py_None); resultobj = Py_None;
32061 return resultobj;
32062 fail:
32063 return NULL;
32064 }
32065
32066
32067 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32068 PyObject *resultobj;
32069 wxWindow *arg1 = (wxWindow *) 0 ;
32070 bool result;
32071 PyObject * obj0 = 0 ;
32072 char *kwnames[] = {
32073 (char *) "self", NULL
32074 };
32075
32076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32078 if (SWIG_arg_fail(1)) SWIG_fail;
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32082
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 {
32087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32088 }
32089 return resultobj;
32090 fail:
32091 return NULL;
32092 }
32093
32094
32095 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32096 PyObject *obj;
32097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32098 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32099 Py_INCREF(obj);
32100 return Py_BuildValue((char *)"");
32101 }
32102 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32103 PyObject *resultobj;
32104 long arg1 ;
32105 wxWindow *arg2 = (wxWindow *) NULL ;
32106 wxWindow *result;
32107 PyObject * obj0 = 0 ;
32108 PyObject * obj1 = 0 ;
32109 char *kwnames[] = {
32110 (char *) "id",(char *) "parent", NULL
32111 };
32112
32113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32114 {
32115 arg1 = (long)(SWIG_As_long(obj0));
32116 if (SWIG_arg_fail(1)) SWIG_fail;
32117 }
32118 if (obj1) {
32119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32120 if (SWIG_arg_fail(2)) SWIG_fail;
32121 }
32122 {
32123 if (!wxPyCheckForApp()) SWIG_fail;
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32126
32127 wxPyEndAllowThreads(__tstate);
32128 if (PyErr_Occurred()) SWIG_fail;
32129 }
32130 {
32131 resultobj = wxPyMake_wxObject(result, 0);
32132 }
32133 return resultobj;
32134 fail:
32135 return NULL;
32136 }
32137
32138
32139 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32140 PyObject *resultobj;
32141 wxString *arg1 = 0 ;
32142 wxWindow *arg2 = (wxWindow *) NULL ;
32143 wxWindow *result;
32144 bool temp1 = false ;
32145 PyObject * obj0 = 0 ;
32146 PyObject * obj1 = 0 ;
32147 char *kwnames[] = {
32148 (char *) "name",(char *) "parent", NULL
32149 };
32150
32151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32152 {
32153 arg1 = wxString_in_helper(obj0);
32154 if (arg1 == NULL) SWIG_fail;
32155 temp1 = true;
32156 }
32157 if (obj1) {
32158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32159 if (SWIG_arg_fail(2)) SWIG_fail;
32160 }
32161 {
32162 if (!wxPyCheckForApp()) SWIG_fail;
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32165
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 {
32170 resultobj = wxPyMake_wxObject(result, 0);
32171 }
32172 {
32173 if (temp1)
32174 delete arg1;
32175 }
32176 return resultobj;
32177 fail:
32178 {
32179 if (temp1)
32180 delete arg1;
32181 }
32182 return NULL;
32183 }
32184
32185
32186 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32187 PyObject *resultobj;
32188 wxString *arg1 = 0 ;
32189 wxWindow *arg2 = (wxWindow *) NULL ;
32190 wxWindow *result;
32191 bool temp1 = false ;
32192 PyObject * obj0 = 0 ;
32193 PyObject * obj1 = 0 ;
32194 char *kwnames[] = {
32195 (char *) "label",(char *) "parent", NULL
32196 };
32197
32198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32199 {
32200 arg1 = wxString_in_helper(obj0);
32201 if (arg1 == NULL) SWIG_fail;
32202 temp1 = true;
32203 }
32204 if (obj1) {
32205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32206 if (SWIG_arg_fail(2)) SWIG_fail;
32207 }
32208 {
32209 if (!wxPyCheckForApp()) SWIG_fail;
32210 PyThreadState* __tstate = wxPyBeginAllowThreads();
32211 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32212
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 {
32217 resultobj = wxPyMake_wxObject(result, 0);
32218 }
32219 {
32220 if (temp1)
32221 delete arg1;
32222 }
32223 return resultobj;
32224 fail:
32225 {
32226 if (temp1)
32227 delete arg1;
32228 }
32229 return NULL;
32230 }
32231
32232
32233 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32234 PyObject *resultobj;
32235 wxWindow *arg1 = (wxWindow *) 0 ;
32236 unsigned long arg2 ;
32237 wxWindow *result;
32238 PyObject * obj0 = 0 ;
32239 PyObject * obj1 = 0 ;
32240 char *kwnames[] = {
32241 (char *) "parent",(char *) "_hWnd", NULL
32242 };
32243
32244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32246 if (SWIG_arg_fail(1)) SWIG_fail;
32247 {
32248 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32249 if (SWIG_arg_fail(2)) SWIG_fail;
32250 }
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32254
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 {
32259 resultobj = wxPyMake_wxObject(result, 0);
32260 }
32261 return resultobj;
32262 fail:
32263 return NULL;
32264 }
32265
32266
32267 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32268 PyObject *resultobj;
32269 PyObject *result;
32270 char *kwnames[] = {
32271 NULL
32272 };
32273
32274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (PyObject *)GetTopLevelWindows();
32278
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 resultobj = result;
32283 return resultobj;
32284 fail:
32285 return NULL;
32286 }
32287
32288
32289 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32290 PyObject *resultobj;
32291 wxValidator *result;
32292 char *kwnames[] = {
32293 NULL
32294 };
32295
32296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32297 {
32298 PyThreadState* __tstate = wxPyBeginAllowThreads();
32299 result = (wxValidator *)new wxValidator();
32300
32301 wxPyEndAllowThreads(__tstate);
32302 if (PyErr_Occurred()) SWIG_fail;
32303 }
32304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32305 return resultobj;
32306 fail:
32307 return NULL;
32308 }
32309
32310
32311 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32312 PyObject *resultobj;
32313 wxValidator *arg1 = (wxValidator *) 0 ;
32314 wxValidator *result;
32315 PyObject * obj0 = 0 ;
32316 char *kwnames[] = {
32317 (char *) "self", NULL
32318 };
32319
32320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32322 if (SWIG_arg_fail(1)) SWIG_fail;
32323 {
32324 PyThreadState* __tstate = wxPyBeginAllowThreads();
32325 result = (wxValidator *)(arg1)->Clone();
32326
32327 wxPyEndAllowThreads(__tstate);
32328 if (PyErr_Occurred()) SWIG_fail;
32329 }
32330 {
32331 resultobj = wxPyMake_wxObject(result, 0);
32332 }
32333 return resultobj;
32334 fail:
32335 return NULL;
32336 }
32337
32338
32339 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32340 PyObject *resultobj;
32341 wxValidator *arg1 = (wxValidator *) 0 ;
32342 wxWindow *arg2 = (wxWindow *) 0 ;
32343 bool result;
32344 PyObject * obj0 = 0 ;
32345 PyObject * obj1 = 0 ;
32346 char *kwnames[] = {
32347 (char *) "self",(char *) "parent", NULL
32348 };
32349
32350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32352 if (SWIG_arg_fail(1)) SWIG_fail;
32353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32354 if (SWIG_arg_fail(2)) SWIG_fail;
32355 {
32356 PyThreadState* __tstate = wxPyBeginAllowThreads();
32357 result = (bool)(arg1)->Validate(arg2);
32358
32359 wxPyEndAllowThreads(__tstate);
32360 if (PyErr_Occurred()) SWIG_fail;
32361 }
32362 {
32363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32364 }
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32372 PyObject *resultobj;
32373 wxValidator *arg1 = (wxValidator *) 0 ;
32374 bool result;
32375 PyObject * obj0 = 0 ;
32376 char *kwnames[] = {
32377 (char *) "self", NULL
32378 };
32379
32380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32382 if (SWIG_arg_fail(1)) SWIG_fail;
32383 {
32384 PyThreadState* __tstate = wxPyBeginAllowThreads();
32385 result = (bool)(arg1)->TransferToWindow();
32386
32387 wxPyEndAllowThreads(__tstate);
32388 if (PyErr_Occurred()) SWIG_fail;
32389 }
32390 {
32391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32392 }
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32400 PyObject *resultobj;
32401 wxValidator *arg1 = (wxValidator *) 0 ;
32402 bool result;
32403 PyObject * obj0 = 0 ;
32404 char *kwnames[] = {
32405 (char *) "self", NULL
32406 };
32407
32408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32410 if (SWIG_arg_fail(1)) SWIG_fail;
32411 {
32412 PyThreadState* __tstate = wxPyBeginAllowThreads();
32413 result = (bool)(arg1)->TransferFromWindow();
32414
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 {
32419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32420 }
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32428 PyObject *resultobj;
32429 wxValidator *arg1 = (wxValidator *) 0 ;
32430 wxWindow *result;
32431 PyObject * obj0 = 0 ;
32432 char *kwnames[] = {
32433 (char *) "self", NULL
32434 };
32435
32436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32438 if (SWIG_arg_fail(1)) SWIG_fail;
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 result = (wxWindow *)(arg1)->GetWindow();
32442
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 resultobj = wxPyMake_wxObject(result, 0);
32448 }
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32456 PyObject *resultobj;
32457 wxValidator *arg1 = (wxValidator *) 0 ;
32458 wxWindow *arg2 = (wxWindow *) 0 ;
32459 PyObject * obj0 = 0 ;
32460 PyObject * obj1 = 0 ;
32461 char *kwnames[] = {
32462 (char *) "self",(char *) "window", NULL
32463 };
32464
32465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32467 if (SWIG_arg_fail(1)) SWIG_fail;
32468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32469 if (SWIG_arg_fail(2)) SWIG_fail;
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 (arg1)->SetWindow(arg2);
32473
32474 wxPyEndAllowThreads(__tstate);
32475 if (PyErr_Occurred()) SWIG_fail;
32476 }
32477 Py_INCREF(Py_None); resultobj = Py_None;
32478 return resultobj;
32479 fail:
32480 return NULL;
32481 }
32482
32483
32484 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32485 PyObject *resultobj;
32486 bool result;
32487 char *kwnames[] = {
32488 NULL
32489 };
32490
32491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 result = (bool)wxValidator::IsSilent();
32495
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 {
32500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32501 }
32502 return resultobj;
32503 fail:
32504 return NULL;
32505 }
32506
32507
32508 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32509 PyObject *resultobj;
32510 int arg1 = (int) true ;
32511 PyObject * obj0 = 0 ;
32512 char *kwnames[] = {
32513 (char *) "doIt", NULL
32514 };
32515
32516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32517 if (obj0) {
32518 {
32519 arg1 = (int)(SWIG_As_int(obj0));
32520 if (SWIG_arg_fail(1)) SWIG_fail;
32521 }
32522 }
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 wxValidator::SetBellOnError(arg1);
32526
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 Py_INCREF(Py_None); resultobj = Py_None;
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32538 PyObject *obj;
32539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32540 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32541 Py_INCREF(obj);
32542 return Py_BuildValue((char *)"");
32543 }
32544 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj;
32546 wxPyValidator *result;
32547 char *kwnames[] = {
32548 NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32552 {
32553 PyThreadState* __tstate = wxPyBeginAllowThreads();
32554 result = (wxPyValidator *)new wxPyValidator();
32555
32556 wxPyEndAllowThreads(__tstate);
32557 if (PyErr_Occurred()) SWIG_fail;
32558 }
32559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32560 return resultobj;
32561 fail:
32562 return NULL;
32563 }
32564
32565
32566 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32567 PyObject *resultobj;
32568 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32569 PyObject *arg2 = (PyObject *) 0 ;
32570 PyObject *arg3 = (PyObject *) 0 ;
32571 int arg4 = (int) true ;
32572 PyObject * obj0 = 0 ;
32573 PyObject * obj1 = 0 ;
32574 PyObject * obj2 = 0 ;
32575 PyObject * obj3 = 0 ;
32576 char *kwnames[] = {
32577 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32578 };
32579
32580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32582 if (SWIG_arg_fail(1)) SWIG_fail;
32583 arg2 = obj1;
32584 arg3 = obj2;
32585 if (obj3) {
32586 {
32587 arg4 = (int)(SWIG_As_int(obj3));
32588 if (SWIG_arg_fail(4)) SWIG_fail;
32589 }
32590 }
32591 {
32592 PyThreadState* __tstate = wxPyBeginAllowThreads();
32593 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32594
32595 wxPyEndAllowThreads(__tstate);
32596 if (PyErr_Occurred()) SWIG_fail;
32597 }
32598 Py_INCREF(Py_None); resultobj = Py_None;
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32606 PyObject *obj;
32607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32608 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32609 Py_INCREF(obj);
32610 return Py_BuildValue((char *)"");
32611 }
32612 static int _wrap_DefaultValidator_set(PyObject *) {
32613 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32614 return 1;
32615 }
32616
32617
32618 static PyObject *_wrap_DefaultValidator_get(void) {
32619 PyObject *pyobj;
32620
32621 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32622 return pyobj;
32623 }
32624
32625
32626 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32627 PyObject *resultobj;
32628 wxString const &arg1_defvalue = wxPyEmptyString ;
32629 wxString *arg1 = (wxString *) &arg1_defvalue ;
32630 long arg2 = (long) 0 ;
32631 wxMenu *result;
32632 bool temp1 = false ;
32633 PyObject * obj0 = 0 ;
32634 PyObject * obj1 = 0 ;
32635 char *kwnames[] = {
32636 (char *) "title",(char *) "style", NULL
32637 };
32638
32639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32640 if (obj0) {
32641 {
32642 arg1 = wxString_in_helper(obj0);
32643 if (arg1 == NULL) SWIG_fail;
32644 temp1 = true;
32645 }
32646 }
32647 if (obj1) {
32648 {
32649 arg2 = (long)(SWIG_As_long(obj1));
32650 if (SWIG_arg_fail(2)) SWIG_fail;
32651 }
32652 }
32653 {
32654 if (!wxPyCheckForApp()) SWIG_fail;
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32657
32658 wxPyEndAllowThreads(__tstate);
32659 if (PyErr_Occurred()) SWIG_fail;
32660 }
32661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32662 {
32663 if (temp1)
32664 delete arg1;
32665 }
32666 return resultobj;
32667 fail:
32668 {
32669 if (temp1)
32670 delete arg1;
32671 }
32672 return NULL;
32673 }
32674
32675
32676 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32677 PyObject *resultobj;
32678 wxMenu *arg1 = (wxMenu *) 0 ;
32679 int arg2 ;
32680 wxString *arg3 = 0 ;
32681 wxString const &arg4_defvalue = wxPyEmptyString ;
32682 wxString *arg4 = (wxString *) &arg4_defvalue ;
32683 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32684 wxMenuItem *result;
32685 bool temp3 = false ;
32686 bool temp4 = false ;
32687 PyObject * obj0 = 0 ;
32688 PyObject * obj1 = 0 ;
32689 PyObject * obj2 = 0 ;
32690 PyObject * obj3 = 0 ;
32691 PyObject * obj4 = 0 ;
32692 char *kwnames[] = {
32693 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32694 };
32695
32696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32698 if (SWIG_arg_fail(1)) SWIG_fail;
32699 {
32700 arg2 = (int)(SWIG_As_int(obj1));
32701 if (SWIG_arg_fail(2)) SWIG_fail;
32702 }
32703 {
32704 arg3 = wxString_in_helper(obj2);
32705 if (arg3 == NULL) SWIG_fail;
32706 temp3 = true;
32707 }
32708 if (obj3) {
32709 {
32710 arg4 = wxString_in_helper(obj3);
32711 if (arg4 == NULL) SWIG_fail;
32712 temp4 = true;
32713 }
32714 }
32715 if (obj4) {
32716 {
32717 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32718 if (SWIG_arg_fail(5)) SWIG_fail;
32719 }
32720 }
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32724
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 {
32729 resultobj = wxPyMake_wxObject(result, 0);
32730 }
32731 {
32732 if (temp3)
32733 delete arg3;
32734 }
32735 {
32736 if (temp4)
32737 delete arg4;
32738 }
32739 return resultobj;
32740 fail:
32741 {
32742 if (temp3)
32743 delete arg3;
32744 }
32745 {
32746 if (temp4)
32747 delete arg4;
32748 }
32749 return NULL;
32750 }
32751
32752
32753 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj;
32755 wxMenu *arg1 = (wxMenu *) 0 ;
32756 wxMenuItem *result;
32757 PyObject * obj0 = 0 ;
32758 char *kwnames[] = {
32759 (char *) "self", NULL
32760 };
32761
32762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32764 if (SWIG_arg_fail(1)) SWIG_fail;
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 result = (wxMenuItem *)(arg1)->AppendSeparator();
32768
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 {
32773 resultobj = wxPyMake_wxObject(result, 0);
32774 }
32775 return resultobj;
32776 fail:
32777 return NULL;
32778 }
32779
32780
32781 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32782 PyObject *resultobj;
32783 wxMenu *arg1 = (wxMenu *) 0 ;
32784 int arg2 ;
32785 wxString *arg3 = 0 ;
32786 wxString const &arg4_defvalue = wxPyEmptyString ;
32787 wxString *arg4 = (wxString *) &arg4_defvalue ;
32788 wxMenuItem *result;
32789 bool temp3 = false ;
32790 bool temp4 = false ;
32791 PyObject * obj0 = 0 ;
32792 PyObject * obj1 = 0 ;
32793 PyObject * obj2 = 0 ;
32794 PyObject * obj3 = 0 ;
32795 char *kwnames[] = {
32796 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32797 };
32798
32799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32801 if (SWIG_arg_fail(1)) SWIG_fail;
32802 {
32803 arg2 = (int)(SWIG_As_int(obj1));
32804 if (SWIG_arg_fail(2)) SWIG_fail;
32805 }
32806 {
32807 arg3 = wxString_in_helper(obj2);
32808 if (arg3 == NULL) SWIG_fail;
32809 temp3 = true;
32810 }
32811 if (obj3) {
32812 {
32813 arg4 = wxString_in_helper(obj3);
32814 if (arg4 == NULL) SWIG_fail;
32815 temp4 = true;
32816 }
32817 }
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32821
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 {
32826 resultobj = wxPyMake_wxObject(result, 0);
32827 }
32828 {
32829 if (temp3)
32830 delete arg3;
32831 }
32832 {
32833 if (temp4)
32834 delete arg4;
32835 }
32836 return resultobj;
32837 fail:
32838 {
32839 if (temp3)
32840 delete arg3;
32841 }
32842 {
32843 if (temp4)
32844 delete arg4;
32845 }
32846 return NULL;
32847 }
32848
32849
32850 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj;
32852 wxMenu *arg1 = (wxMenu *) 0 ;
32853 int arg2 ;
32854 wxString *arg3 = 0 ;
32855 wxString const &arg4_defvalue = wxPyEmptyString ;
32856 wxString *arg4 = (wxString *) &arg4_defvalue ;
32857 wxMenuItem *result;
32858 bool temp3 = false ;
32859 bool temp4 = false ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 PyObject * obj2 = 0 ;
32863 PyObject * obj3 = 0 ;
32864 char *kwnames[] = {
32865 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32866 };
32867
32868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32870 if (SWIG_arg_fail(1)) SWIG_fail;
32871 {
32872 arg2 = (int)(SWIG_As_int(obj1));
32873 if (SWIG_arg_fail(2)) SWIG_fail;
32874 }
32875 {
32876 arg3 = wxString_in_helper(obj2);
32877 if (arg3 == NULL) SWIG_fail;
32878 temp3 = true;
32879 }
32880 if (obj3) {
32881 {
32882 arg4 = wxString_in_helper(obj3);
32883 if (arg4 == NULL) SWIG_fail;
32884 temp4 = true;
32885 }
32886 }
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32890
32891 wxPyEndAllowThreads(__tstate);
32892 if (PyErr_Occurred()) SWIG_fail;
32893 }
32894 {
32895 resultobj = wxPyMake_wxObject(result, 0);
32896 }
32897 {
32898 if (temp3)
32899 delete arg3;
32900 }
32901 {
32902 if (temp4)
32903 delete arg4;
32904 }
32905 return resultobj;
32906 fail:
32907 {
32908 if (temp3)
32909 delete arg3;
32910 }
32911 {
32912 if (temp4)
32913 delete arg4;
32914 }
32915 return NULL;
32916 }
32917
32918
32919 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32920 PyObject *resultobj;
32921 wxMenu *arg1 = (wxMenu *) 0 ;
32922 int arg2 ;
32923 wxString *arg3 = 0 ;
32924 wxMenu *arg4 = (wxMenu *) 0 ;
32925 wxString const &arg5_defvalue = wxPyEmptyString ;
32926 wxString *arg5 = (wxString *) &arg5_defvalue ;
32927 wxMenuItem *result;
32928 bool temp3 = false ;
32929 bool temp5 = false ;
32930 PyObject * obj0 = 0 ;
32931 PyObject * obj1 = 0 ;
32932 PyObject * obj2 = 0 ;
32933 PyObject * obj3 = 0 ;
32934 PyObject * obj4 = 0 ;
32935 char *kwnames[] = {
32936 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32937 };
32938
32939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32941 if (SWIG_arg_fail(1)) SWIG_fail;
32942 {
32943 arg2 = (int)(SWIG_As_int(obj1));
32944 if (SWIG_arg_fail(2)) SWIG_fail;
32945 }
32946 {
32947 arg3 = wxString_in_helper(obj2);
32948 if (arg3 == NULL) SWIG_fail;
32949 temp3 = true;
32950 }
32951 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32952 if (SWIG_arg_fail(4)) SWIG_fail;
32953 if (obj4) {
32954 {
32955 arg5 = wxString_in_helper(obj4);
32956 if (arg5 == NULL) SWIG_fail;
32957 temp5 = true;
32958 }
32959 }
32960 {
32961 PyThreadState* __tstate = wxPyBeginAllowThreads();
32962 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32963
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 {
32968 resultobj = wxPyMake_wxObject(result, 0);
32969 }
32970 {
32971 if (temp3)
32972 delete arg3;
32973 }
32974 {
32975 if (temp5)
32976 delete arg5;
32977 }
32978 return resultobj;
32979 fail:
32980 {
32981 if (temp3)
32982 delete arg3;
32983 }
32984 {
32985 if (temp5)
32986 delete arg5;
32987 }
32988 return NULL;
32989 }
32990
32991
32992 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32993 PyObject *resultobj;
32994 wxMenu *arg1 = (wxMenu *) 0 ;
32995 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32996 wxMenuItem *result;
32997 PyObject * obj0 = 0 ;
32998 PyObject * obj1 = 0 ;
32999 char *kwnames[] = {
33000 (char *) "self",(char *) "item", NULL
33001 };
33002
33003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33005 if (SWIG_arg_fail(1)) SWIG_fail;
33006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33007 if (SWIG_arg_fail(2)) SWIG_fail;
33008 {
33009 PyThreadState* __tstate = wxPyBeginAllowThreads();
33010 result = (wxMenuItem *)(arg1)->Append(arg2);
33011
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 {
33016 resultobj = wxPyMake_wxObject(result, 0);
33017 }
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33025 PyObject *resultobj;
33026 wxMenu *arg1 = (wxMenu *) 0 ;
33027 PyObject * obj0 = 0 ;
33028 char *kwnames[] = {
33029 (char *) "self", NULL
33030 };
33031
33032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33034 if (SWIG_arg_fail(1)) SWIG_fail;
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 (arg1)->Break();
33038
33039 wxPyEndAllowThreads(__tstate);
33040 if (PyErr_Occurred()) SWIG_fail;
33041 }
33042 Py_INCREF(Py_None); resultobj = Py_None;
33043 return resultobj;
33044 fail:
33045 return NULL;
33046 }
33047
33048
33049 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33050 PyObject *resultobj;
33051 wxMenu *arg1 = (wxMenu *) 0 ;
33052 size_t arg2 ;
33053 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33054 wxMenuItem *result;
33055 PyObject * obj0 = 0 ;
33056 PyObject * obj1 = 0 ;
33057 PyObject * obj2 = 0 ;
33058 char *kwnames[] = {
33059 (char *) "self",(char *) "pos",(char *) "item", NULL
33060 };
33061
33062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33064 if (SWIG_arg_fail(1)) SWIG_fail;
33065 {
33066 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33067 if (SWIG_arg_fail(2)) SWIG_fail;
33068 }
33069 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33070 if (SWIG_arg_fail(3)) SWIG_fail;
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33074
33075 wxPyEndAllowThreads(__tstate);
33076 if (PyErr_Occurred()) SWIG_fail;
33077 }
33078 {
33079 resultobj = wxPyMake_wxObject(result, 0);
33080 }
33081 return resultobj;
33082 fail:
33083 return NULL;
33084 }
33085
33086
33087 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33088 PyObject *resultobj;
33089 wxMenu *arg1 = (wxMenu *) 0 ;
33090 size_t arg2 ;
33091 int arg3 ;
33092 wxString *arg4 = 0 ;
33093 wxString const &arg5_defvalue = wxPyEmptyString ;
33094 wxString *arg5 = (wxString *) &arg5_defvalue ;
33095 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33096 wxMenuItem *result;
33097 bool temp4 = false ;
33098 bool temp5 = false ;
33099 PyObject * obj0 = 0 ;
33100 PyObject * obj1 = 0 ;
33101 PyObject * obj2 = 0 ;
33102 PyObject * obj3 = 0 ;
33103 PyObject * obj4 = 0 ;
33104 PyObject * obj5 = 0 ;
33105 char *kwnames[] = {
33106 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33107 };
33108
33109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33111 if (SWIG_arg_fail(1)) SWIG_fail;
33112 {
33113 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33114 if (SWIG_arg_fail(2)) SWIG_fail;
33115 }
33116 {
33117 arg3 = (int)(SWIG_As_int(obj2));
33118 if (SWIG_arg_fail(3)) SWIG_fail;
33119 }
33120 {
33121 arg4 = wxString_in_helper(obj3);
33122 if (arg4 == NULL) SWIG_fail;
33123 temp4 = true;
33124 }
33125 if (obj4) {
33126 {
33127 arg5 = wxString_in_helper(obj4);
33128 if (arg5 == NULL) SWIG_fail;
33129 temp5 = true;
33130 }
33131 }
33132 if (obj5) {
33133 {
33134 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33135 if (SWIG_arg_fail(6)) SWIG_fail;
33136 }
33137 }
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33141
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 {
33146 resultobj = wxPyMake_wxObject(result, 0);
33147 }
33148 {
33149 if (temp4)
33150 delete arg4;
33151 }
33152 {
33153 if (temp5)
33154 delete arg5;
33155 }
33156 return resultobj;
33157 fail:
33158 {
33159 if (temp4)
33160 delete arg4;
33161 }
33162 {
33163 if (temp5)
33164 delete arg5;
33165 }
33166 return NULL;
33167 }
33168
33169
33170 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33171 PyObject *resultobj;
33172 wxMenu *arg1 = (wxMenu *) 0 ;
33173 size_t arg2 ;
33174 wxMenuItem *result;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 char *kwnames[] = {
33178 (char *) "self",(char *) "pos", NULL
33179 };
33180
33181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33183 if (SWIG_arg_fail(1)) SWIG_fail;
33184 {
33185 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33186 if (SWIG_arg_fail(2)) SWIG_fail;
33187 }
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33191
33192 wxPyEndAllowThreads(__tstate);
33193 if (PyErr_Occurred()) SWIG_fail;
33194 }
33195 {
33196 resultobj = wxPyMake_wxObject(result, 0);
33197 }
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33205 PyObject *resultobj;
33206 wxMenu *arg1 = (wxMenu *) 0 ;
33207 size_t arg2 ;
33208 int arg3 ;
33209 wxString *arg4 = 0 ;
33210 wxString const &arg5_defvalue = wxPyEmptyString ;
33211 wxString *arg5 = (wxString *) &arg5_defvalue ;
33212 wxMenuItem *result;
33213 bool temp4 = false ;
33214 bool temp5 = false ;
33215 PyObject * obj0 = 0 ;
33216 PyObject * obj1 = 0 ;
33217 PyObject * obj2 = 0 ;
33218 PyObject * obj3 = 0 ;
33219 PyObject * obj4 = 0 ;
33220 char *kwnames[] = {
33221 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33222 };
33223
33224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33226 if (SWIG_arg_fail(1)) SWIG_fail;
33227 {
33228 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33229 if (SWIG_arg_fail(2)) SWIG_fail;
33230 }
33231 {
33232 arg3 = (int)(SWIG_As_int(obj2));
33233 if (SWIG_arg_fail(3)) SWIG_fail;
33234 }
33235 {
33236 arg4 = wxString_in_helper(obj3);
33237 if (arg4 == NULL) SWIG_fail;
33238 temp4 = true;
33239 }
33240 if (obj4) {
33241 {
33242 arg5 = wxString_in_helper(obj4);
33243 if (arg5 == NULL) SWIG_fail;
33244 temp5 = true;
33245 }
33246 }
33247 {
33248 PyThreadState* __tstate = wxPyBeginAllowThreads();
33249 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33250
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 {
33255 resultobj = wxPyMake_wxObject(result, 0);
33256 }
33257 {
33258 if (temp4)
33259 delete arg4;
33260 }
33261 {
33262 if (temp5)
33263 delete arg5;
33264 }
33265 return resultobj;
33266 fail:
33267 {
33268 if (temp4)
33269 delete arg4;
33270 }
33271 {
33272 if (temp5)
33273 delete arg5;
33274 }
33275 return NULL;
33276 }
33277
33278
33279 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33280 PyObject *resultobj;
33281 wxMenu *arg1 = (wxMenu *) 0 ;
33282 size_t arg2 ;
33283 int arg3 ;
33284 wxString *arg4 = 0 ;
33285 wxString const &arg5_defvalue = wxPyEmptyString ;
33286 wxString *arg5 = (wxString *) &arg5_defvalue ;
33287 wxMenuItem *result;
33288 bool temp4 = false ;
33289 bool temp5 = false ;
33290 PyObject * obj0 = 0 ;
33291 PyObject * obj1 = 0 ;
33292 PyObject * obj2 = 0 ;
33293 PyObject * obj3 = 0 ;
33294 PyObject * obj4 = 0 ;
33295 char *kwnames[] = {
33296 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33297 };
33298
33299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33301 if (SWIG_arg_fail(1)) SWIG_fail;
33302 {
33303 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33304 if (SWIG_arg_fail(2)) SWIG_fail;
33305 }
33306 {
33307 arg3 = (int)(SWIG_As_int(obj2));
33308 if (SWIG_arg_fail(3)) SWIG_fail;
33309 }
33310 {
33311 arg4 = wxString_in_helper(obj3);
33312 if (arg4 == NULL) SWIG_fail;
33313 temp4 = true;
33314 }
33315 if (obj4) {
33316 {
33317 arg5 = wxString_in_helper(obj4);
33318 if (arg5 == NULL) SWIG_fail;
33319 temp5 = true;
33320 }
33321 }
33322 {
33323 PyThreadState* __tstate = wxPyBeginAllowThreads();
33324 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33325
33326 wxPyEndAllowThreads(__tstate);
33327 if (PyErr_Occurred()) SWIG_fail;
33328 }
33329 {
33330 resultobj = wxPyMake_wxObject(result, 0);
33331 }
33332 {
33333 if (temp4)
33334 delete arg4;
33335 }
33336 {
33337 if (temp5)
33338 delete arg5;
33339 }
33340 return resultobj;
33341 fail:
33342 {
33343 if (temp4)
33344 delete arg4;
33345 }
33346 {
33347 if (temp5)
33348 delete arg5;
33349 }
33350 return NULL;
33351 }
33352
33353
33354 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33355 PyObject *resultobj;
33356 wxMenu *arg1 = (wxMenu *) 0 ;
33357 size_t arg2 ;
33358 int arg3 ;
33359 wxString *arg4 = 0 ;
33360 wxMenu *arg5 = (wxMenu *) 0 ;
33361 wxString const &arg6_defvalue = wxPyEmptyString ;
33362 wxString *arg6 = (wxString *) &arg6_defvalue ;
33363 wxMenuItem *result;
33364 bool temp4 = false ;
33365 bool temp6 = false ;
33366 PyObject * obj0 = 0 ;
33367 PyObject * obj1 = 0 ;
33368 PyObject * obj2 = 0 ;
33369 PyObject * obj3 = 0 ;
33370 PyObject * obj4 = 0 ;
33371 PyObject * obj5 = 0 ;
33372 char *kwnames[] = {
33373 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33374 };
33375
33376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33378 if (SWIG_arg_fail(1)) SWIG_fail;
33379 {
33380 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33381 if (SWIG_arg_fail(2)) SWIG_fail;
33382 }
33383 {
33384 arg3 = (int)(SWIG_As_int(obj2));
33385 if (SWIG_arg_fail(3)) SWIG_fail;
33386 }
33387 {
33388 arg4 = wxString_in_helper(obj3);
33389 if (arg4 == NULL) SWIG_fail;
33390 temp4 = true;
33391 }
33392 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33393 if (SWIG_arg_fail(5)) SWIG_fail;
33394 if (obj5) {
33395 {
33396 arg6 = wxString_in_helper(obj5);
33397 if (arg6 == NULL) SWIG_fail;
33398 temp6 = true;
33399 }
33400 }
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33404
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 {
33409 resultobj = wxPyMake_wxObject(result, 0);
33410 }
33411 {
33412 if (temp4)
33413 delete arg4;
33414 }
33415 {
33416 if (temp6)
33417 delete arg6;
33418 }
33419 return resultobj;
33420 fail:
33421 {
33422 if (temp4)
33423 delete arg4;
33424 }
33425 {
33426 if (temp6)
33427 delete arg6;
33428 }
33429 return NULL;
33430 }
33431
33432
33433 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33434 PyObject *resultobj;
33435 wxMenu *arg1 = (wxMenu *) 0 ;
33436 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33437 wxMenuItem *result;
33438 PyObject * obj0 = 0 ;
33439 PyObject * obj1 = 0 ;
33440 char *kwnames[] = {
33441 (char *) "self",(char *) "item", NULL
33442 };
33443
33444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33446 if (SWIG_arg_fail(1)) SWIG_fail;
33447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33448 if (SWIG_arg_fail(2)) SWIG_fail;
33449 {
33450 PyThreadState* __tstate = wxPyBeginAllowThreads();
33451 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33452
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 {
33457 resultobj = wxPyMake_wxObject(result, 0);
33458 }
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33466 PyObject *resultobj;
33467 wxMenu *arg1 = (wxMenu *) 0 ;
33468 int arg2 ;
33469 wxString *arg3 = 0 ;
33470 wxString const &arg4_defvalue = wxPyEmptyString ;
33471 wxString *arg4 = (wxString *) &arg4_defvalue ;
33472 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33473 wxMenuItem *result;
33474 bool temp3 = false ;
33475 bool temp4 = false ;
33476 PyObject * obj0 = 0 ;
33477 PyObject * obj1 = 0 ;
33478 PyObject * obj2 = 0 ;
33479 PyObject * obj3 = 0 ;
33480 PyObject * obj4 = 0 ;
33481 char *kwnames[] = {
33482 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33483 };
33484
33485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33487 if (SWIG_arg_fail(1)) SWIG_fail;
33488 {
33489 arg2 = (int)(SWIG_As_int(obj1));
33490 if (SWIG_arg_fail(2)) SWIG_fail;
33491 }
33492 {
33493 arg3 = wxString_in_helper(obj2);
33494 if (arg3 == NULL) SWIG_fail;
33495 temp3 = true;
33496 }
33497 if (obj3) {
33498 {
33499 arg4 = wxString_in_helper(obj3);
33500 if (arg4 == NULL) SWIG_fail;
33501 temp4 = true;
33502 }
33503 }
33504 if (obj4) {
33505 {
33506 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33507 if (SWIG_arg_fail(5)) SWIG_fail;
33508 }
33509 }
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33513
33514 wxPyEndAllowThreads(__tstate);
33515 if (PyErr_Occurred()) SWIG_fail;
33516 }
33517 {
33518 resultobj = wxPyMake_wxObject(result, 0);
33519 }
33520 {
33521 if (temp3)
33522 delete arg3;
33523 }
33524 {
33525 if (temp4)
33526 delete arg4;
33527 }
33528 return resultobj;
33529 fail:
33530 {
33531 if (temp3)
33532 delete arg3;
33533 }
33534 {
33535 if (temp4)
33536 delete arg4;
33537 }
33538 return NULL;
33539 }
33540
33541
33542 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33543 PyObject *resultobj;
33544 wxMenu *arg1 = (wxMenu *) 0 ;
33545 wxMenuItem *result;
33546 PyObject * obj0 = 0 ;
33547 char *kwnames[] = {
33548 (char *) "self", NULL
33549 };
33550
33551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33553 if (SWIG_arg_fail(1)) SWIG_fail;
33554 {
33555 PyThreadState* __tstate = wxPyBeginAllowThreads();
33556 result = (wxMenuItem *)(arg1)->PrependSeparator();
33557
33558 wxPyEndAllowThreads(__tstate);
33559 if (PyErr_Occurred()) SWIG_fail;
33560 }
33561 {
33562 resultobj = wxPyMake_wxObject(result, 0);
33563 }
33564 return resultobj;
33565 fail:
33566 return NULL;
33567 }
33568
33569
33570 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33571 PyObject *resultobj;
33572 wxMenu *arg1 = (wxMenu *) 0 ;
33573 int arg2 ;
33574 wxString *arg3 = 0 ;
33575 wxString const &arg4_defvalue = wxPyEmptyString ;
33576 wxString *arg4 = (wxString *) &arg4_defvalue ;
33577 wxMenuItem *result;
33578 bool temp3 = false ;
33579 bool temp4 = false ;
33580 PyObject * obj0 = 0 ;
33581 PyObject * obj1 = 0 ;
33582 PyObject * obj2 = 0 ;
33583 PyObject * obj3 = 0 ;
33584 char *kwnames[] = {
33585 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33586 };
33587
33588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33590 if (SWIG_arg_fail(1)) SWIG_fail;
33591 {
33592 arg2 = (int)(SWIG_As_int(obj1));
33593 if (SWIG_arg_fail(2)) SWIG_fail;
33594 }
33595 {
33596 arg3 = wxString_in_helper(obj2);
33597 if (arg3 == NULL) SWIG_fail;
33598 temp3 = true;
33599 }
33600 if (obj3) {
33601 {
33602 arg4 = wxString_in_helper(obj3);
33603 if (arg4 == NULL) SWIG_fail;
33604 temp4 = true;
33605 }
33606 }
33607 {
33608 PyThreadState* __tstate = wxPyBeginAllowThreads();
33609 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33610
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 {
33615 resultobj = wxPyMake_wxObject(result, 0);
33616 }
33617 {
33618 if (temp3)
33619 delete arg3;
33620 }
33621 {
33622 if (temp4)
33623 delete arg4;
33624 }
33625 return resultobj;
33626 fail:
33627 {
33628 if (temp3)
33629 delete arg3;
33630 }
33631 {
33632 if (temp4)
33633 delete arg4;
33634 }
33635 return NULL;
33636 }
33637
33638
33639 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33640 PyObject *resultobj;
33641 wxMenu *arg1 = (wxMenu *) 0 ;
33642 int arg2 ;
33643 wxString *arg3 = 0 ;
33644 wxString const &arg4_defvalue = wxPyEmptyString ;
33645 wxString *arg4 = (wxString *) &arg4_defvalue ;
33646 wxMenuItem *result;
33647 bool temp3 = false ;
33648 bool temp4 = false ;
33649 PyObject * obj0 = 0 ;
33650 PyObject * obj1 = 0 ;
33651 PyObject * obj2 = 0 ;
33652 PyObject * obj3 = 0 ;
33653 char *kwnames[] = {
33654 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33655 };
33656
33657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33659 if (SWIG_arg_fail(1)) SWIG_fail;
33660 {
33661 arg2 = (int)(SWIG_As_int(obj1));
33662 if (SWIG_arg_fail(2)) SWIG_fail;
33663 }
33664 {
33665 arg3 = wxString_in_helper(obj2);
33666 if (arg3 == NULL) SWIG_fail;
33667 temp3 = true;
33668 }
33669 if (obj3) {
33670 {
33671 arg4 = wxString_in_helper(obj3);
33672 if (arg4 == NULL) SWIG_fail;
33673 temp4 = true;
33674 }
33675 }
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33679
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 {
33684 resultobj = wxPyMake_wxObject(result, 0);
33685 }
33686 {
33687 if (temp3)
33688 delete arg3;
33689 }
33690 {
33691 if (temp4)
33692 delete arg4;
33693 }
33694 return resultobj;
33695 fail:
33696 {
33697 if (temp3)
33698 delete arg3;
33699 }
33700 {
33701 if (temp4)
33702 delete arg4;
33703 }
33704 return NULL;
33705 }
33706
33707
33708 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33709 PyObject *resultobj;
33710 wxMenu *arg1 = (wxMenu *) 0 ;
33711 int arg2 ;
33712 wxString *arg3 = 0 ;
33713 wxMenu *arg4 = (wxMenu *) 0 ;
33714 wxString const &arg5_defvalue = wxPyEmptyString ;
33715 wxString *arg5 = (wxString *) &arg5_defvalue ;
33716 wxMenuItem *result;
33717 bool temp3 = false ;
33718 bool temp5 = false ;
33719 PyObject * obj0 = 0 ;
33720 PyObject * obj1 = 0 ;
33721 PyObject * obj2 = 0 ;
33722 PyObject * obj3 = 0 ;
33723 PyObject * obj4 = 0 ;
33724 char *kwnames[] = {
33725 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33726 };
33727
33728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33730 if (SWIG_arg_fail(1)) SWIG_fail;
33731 {
33732 arg2 = (int)(SWIG_As_int(obj1));
33733 if (SWIG_arg_fail(2)) SWIG_fail;
33734 }
33735 {
33736 arg3 = wxString_in_helper(obj2);
33737 if (arg3 == NULL) SWIG_fail;
33738 temp3 = true;
33739 }
33740 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33741 if (SWIG_arg_fail(4)) SWIG_fail;
33742 if (obj4) {
33743 {
33744 arg5 = wxString_in_helper(obj4);
33745 if (arg5 == NULL) SWIG_fail;
33746 temp5 = true;
33747 }
33748 }
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33752
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 {
33757 resultobj = wxPyMake_wxObject(result, 0);
33758 }
33759 {
33760 if (temp3)
33761 delete arg3;
33762 }
33763 {
33764 if (temp5)
33765 delete arg5;
33766 }
33767 return resultobj;
33768 fail:
33769 {
33770 if (temp3)
33771 delete arg3;
33772 }
33773 {
33774 if (temp5)
33775 delete arg5;
33776 }
33777 return NULL;
33778 }
33779
33780
33781 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33782 PyObject *resultobj;
33783 wxMenu *arg1 = (wxMenu *) 0 ;
33784 int arg2 ;
33785 wxMenuItem *result;
33786 PyObject * obj0 = 0 ;
33787 PyObject * obj1 = 0 ;
33788 char *kwnames[] = {
33789 (char *) "self",(char *) "id", NULL
33790 };
33791
33792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33794 if (SWIG_arg_fail(1)) SWIG_fail;
33795 {
33796 arg2 = (int)(SWIG_As_int(obj1));
33797 if (SWIG_arg_fail(2)) SWIG_fail;
33798 }
33799 {
33800 PyThreadState* __tstate = wxPyBeginAllowThreads();
33801 result = (wxMenuItem *)(arg1)->Remove(arg2);
33802
33803 wxPyEndAllowThreads(__tstate);
33804 if (PyErr_Occurred()) SWIG_fail;
33805 }
33806 {
33807 resultobj = wxPyMake_wxObject(result, 0);
33808 }
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj;
33817 wxMenu *arg1 = (wxMenu *) 0 ;
33818 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33819 wxMenuItem *result;
33820 PyObject * obj0 = 0 ;
33821 PyObject * obj1 = 0 ;
33822 char *kwnames[] = {
33823 (char *) "self",(char *) "item", NULL
33824 };
33825
33826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33828 if (SWIG_arg_fail(1)) SWIG_fail;
33829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33830 if (SWIG_arg_fail(2)) SWIG_fail;
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 result = (wxMenuItem *)(arg1)->Remove(arg2);
33834
33835 wxPyEndAllowThreads(__tstate);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 }
33838 {
33839 resultobj = wxPyMake_wxObject(result, 0);
33840 }
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj;
33849 wxMenu *arg1 = (wxMenu *) 0 ;
33850 int arg2 ;
33851 bool result;
33852 PyObject * obj0 = 0 ;
33853 PyObject * obj1 = 0 ;
33854 char *kwnames[] = {
33855 (char *) "self",(char *) "id", NULL
33856 };
33857
33858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33860 if (SWIG_arg_fail(1)) SWIG_fail;
33861 {
33862 arg2 = (int)(SWIG_As_int(obj1));
33863 if (SWIG_arg_fail(2)) SWIG_fail;
33864 }
33865 {
33866 PyThreadState* __tstate = wxPyBeginAllowThreads();
33867 result = (bool)(arg1)->Delete(arg2);
33868
33869 wxPyEndAllowThreads(__tstate);
33870 if (PyErr_Occurred()) SWIG_fail;
33871 }
33872 {
33873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33874 }
33875 return resultobj;
33876 fail:
33877 return NULL;
33878 }
33879
33880
33881 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33882 PyObject *resultobj;
33883 wxMenu *arg1 = (wxMenu *) 0 ;
33884 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33885 bool result;
33886 PyObject * obj0 = 0 ;
33887 PyObject * obj1 = 0 ;
33888 char *kwnames[] = {
33889 (char *) "self",(char *) "item", NULL
33890 };
33891
33892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33894 if (SWIG_arg_fail(1)) SWIG_fail;
33895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33896 if (SWIG_arg_fail(2)) SWIG_fail;
33897 {
33898 PyThreadState* __tstate = wxPyBeginAllowThreads();
33899 result = (bool)(arg1)->Delete(arg2);
33900
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33906 }
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj;
33915 wxMenu *arg1 = (wxMenu *) 0 ;
33916 PyObject * obj0 = 0 ;
33917 char *kwnames[] = {
33918 (char *) "self", NULL
33919 };
33920
33921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33923 if (SWIG_arg_fail(1)) SWIG_fail;
33924 {
33925 PyThreadState* __tstate = wxPyBeginAllowThreads();
33926 wxMenu_Destroy(arg1);
33927
33928 wxPyEndAllowThreads(__tstate);
33929 if (PyErr_Occurred()) SWIG_fail;
33930 }
33931 Py_INCREF(Py_None); resultobj = Py_None;
33932 return resultobj;
33933 fail:
33934 return NULL;
33935 }
33936
33937
33938 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33939 PyObject *resultobj;
33940 wxMenu *arg1 = (wxMenu *) 0 ;
33941 int arg2 ;
33942 bool result;
33943 PyObject * obj0 = 0 ;
33944 PyObject * obj1 = 0 ;
33945 char *kwnames[] = {
33946 (char *) "self",(char *) "id", NULL
33947 };
33948
33949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33951 if (SWIG_arg_fail(1)) SWIG_fail;
33952 {
33953 arg2 = (int)(SWIG_As_int(obj1));
33954 if (SWIG_arg_fail(2)) SWIG_fail;
33955 }
33956 {
33957 PyThreadState* __tstate = wxPyBeginAllowThreads();
33958 result = (bool)(arg1)->Destroy(arg2);
33959
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 {
33964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33965 }
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33973 PyObject *resultobj;
33974 wxMenu *arg1 = (wxMenu *) 0 ;
33975 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33976 bool result;
33977 PyObject * obj0 = 0 ;
33978 PyObject * obj1 = 0 ;
33979 char *kwnames[] = {
33980 (char *) "self",(char *) "item", NULL
33981 };
33982
33983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33985 if (SWIG_arg_fail(1)) SWIG_fail;
33986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33987 if (SWIG_arg_fail(2)) SWIG_fail;
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 result = (bool)(arg1)->Destroy(arg2);
33991
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 {
33996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33997 }
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj;
34006 wxMenu *arg1 = (wxMenu *) 0 ;
34007 size_t result;
34008 PyObject * obj0 = 0 ;
34009 char *kwnames[] = {
34010 (char *) "self", NULL
34011 };
34012
34013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34015 if (SWIG_arg_fail(1)) SWIG_fail;
34016 {
34017 PyThreadState* __tstate = wxPyBeginAllowThreads();
34018 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34019
34020 wxPyEndAllowThreads(__tstate);
34021 if (PyErr_Occurred()) SWIG_fail;
34022 }
34023 {
34024 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34025 }
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj;
34034 wxMenu *arg1 = (wxMenu *) 0 ;
34035 PyObject *result;
34036 PyObject * obj0 = 0 ;
34037 char *kwnames[] = {
34038 (char *) "self", NULL
34039 };
34040
34041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34043 if (SWIG_arg_fail(1)) SWIG_fail;
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34047
34048 wxPyEndAllowThreads(__tstate);
34049 if (PyErr_Occurred()) SWIG_fail;
34050 }
34051 resultobj = result;
34052 return resultobj;
34053 fail:
34054 return NULL;
34055 }
34056
34057
34058 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34059 PyObject *resultobj;
34060 wxMenu *arg1 = (wxMenu *) 0 ;
34061 wxString *arg2 = 0 ;
34062 int result;
34063 bool temp2 = false ;
34064 PyObject * obj0 = 0 ;
34065 PyObject * obj1 = 0 ;
34066 char *kwnames[] = {
34067 (char *) "self",(char *) "item", NULL
34068 };
34069
34070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34072 if (SWIG_arg_fail(1)) SWIG_fail;
34073 {
34074 arg2 = wxString_in_helper(obj1);
34075 if (arg2 == NULL) SWIG_fail;
34076 temp2 = true;
34077 }
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34081
34082 wxPyEndAllowThreads(__tstate);
34083 if (PyErr_Occurred()) SWIG_fail;
34084 }
34085 {
34086 resultobj = SWIG_From_int((int)(result));
34087 }
34088 {
34089 if (temp2)
34090 delete arg2;
34091 }
34092 return resultobj;
34093 fail:
34094 {
34095 if (temp2)
34096 delete arg2;
34097 }
34098 return NULL;
34099 }
34100
34101
34102 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj;
34104 wxMenu *arg1 = (wxMenu *) 0 ;
34105 int arg2 ;
34106 wxMenuItem *result;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 char *kwnames[] = {
34110 (char *) "self",(char *) "id", NULL
34111 };
34112
34113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34115 if (SWIG_arg_fail(1)) SWIG_fail;
34116 {
34117 arg2 = (int)(SWIG_As_int(obj1));
34118 if (SWIG_arg_fail(2)) SWIG_fail;
34119 }
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34123
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 {
34128 resultobj = wxPyMake_wxObject(result, 0);
34129 }
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34137 PyObject *resultobj;
34138 wxMenu *arg1 = (wxMenu *) 0 ;
34139 size_t arg2 ;
34140 wxMenuItem *result;
34141 PyObject * obj0 = 0 ;
34142 PyObject * obj1 = 0 ;
34143 char *kwnames[] = {
34144 (char *) "self",(char *) "position", NULL
34145 };
34146
34147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34149 if (SWIG_arg_fail(1)) SWIG_fail;
34150 {
34151 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34152 if (SWIG_arg_fail(2)) SWIG_fail;
34153 }
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34157
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 {
34162 resultobj = wxPyMake_wxObject(result, 0);
34163 }
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj;
34172 wxMenu *arg1 = (wxMenu *) 0 ;
34173 int arg2 ;
34174 bool arg3 ;
34175 PyObject * obj0 = 0 ;
34176 PyObject * obj1 = 0 ;
34177 PyObject * obj2 = 0 ;
34178 char *kwnames[] = {
34179 (char *) "self",(char *) "id",(char *) "enable", NULL
34180 };
34181
34182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
34187 if (SWIG_arg_fail(2)) SWIG_fail;
34188 }
34189 {
34190 arg3 = (bool)(SWIG_As_bool(obj2));
34191 if (SWIG_arg_fail(3)) SWIG_fail;
34192 }
34193 {
34194 PyThreadState* __tstate = wxPyBeginAllowThreads();
34195 (arg1)->Enable(arg2,arg3);
34196
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 Py_INCREF(Py_None); resultobj = Py_None;
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34208 PyObject *resultobj;
34209 wxMenu *arg1 = (wxMenu *) 0 ;
34210 int arg2 ;
34211 bool result;
34212 PyObject * obj0 = 0 ;
34213 PyObject * obj1 = 0 ;
34214 char *kwnames[] = {
34215 (char *) "self",(char *) "id", NULL
34216 };
34217
34218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34220 if (SWIG_arg_fail(1)) SWIG_fail;
34221 {
34222 arg2 = (int)(SWIG_As_int(obj1));
34223 if (SWIG_arg_fail(2)) SWIG_fail;
34224 }
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34228
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 {
34233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34234 }
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34242 PyObject *resultobj;
34243 wxMenu *arg1 = (wxMenu *) 0 ;
34244 int arg2 ;
34245 bool arg3 ;
34246 PyObject * obj0 = 0 ;
34247 PyObject * obj1 = 0 ;
34248 PyObject * obj2 = 0 ;
34249 char *kwnames[] = {
34250 (char *) "self",(char *) "id",(char *) "check", NULL
34251 };
34252
34253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = (bool)(SWIG_As_bool(obj2));
34262 if (SWIG_arg_fail(3)) SWIG_fail;
34263 }
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 (arg1)->Check(arg2,arg3);
34267
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 Py_INCREF(Py_None); resultobj = Py_None;
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34279 PyObject *resultobj;
34280 wxMenu *arg1 = (wxMenu *) 0 ;
34281 int arg2 ;
34282 bool result;
34283 PyObject * obj0 = 0 ;
34284 PyObject * obj1 = 0 ;
34285 char *kwnames[] = {
34286 (char *) "self",(char *) "id", NULL
34287 };
34288
34289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34291 if (SWIG_arg_fail(1)) SWIG_fail;
34292 {
34293 arg2 = (int)(SWIG_As_int(obj1));
34294 if (SWIG_arg_fail(2)) SWIG_fail;
34295 }
34296 {
34297 PyThreadState* __tstate = wxPyBeginAllowThreads();
34298 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34299
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 {
34304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34305 }
34306 return resultobj;
34307 fail:
34308 return NULL;
34309 }
34310
34311
34312 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34313 PyObject *resultobj;
34314 wxMenu *arg1 = (wxMenu *) 0 ;
34315 int arg2 ;
34316 wxString *arg3 = 0 ;
34317 bool temp3 = false ;
34318 PyObject * obj0 = 0 ;
34319 PyObject * obj1 = 0 ;
34320 PyObject * obj2 = 0 ;
34321 char *kwnames[] = {
34322 (char *) "self",(char *) "id",(char *) "label", NULL
34323 };
34324
34325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34327 if (SWIG_arg_fail(1)) SWIG_fail;
34328 {
34329 arg2 = (int)(SWIG_As_int(obj1));
34330 if (SWIG_arg_fail(2)) SWIG_fail;
34331 }
34332 {
34333 arg3 = wxString_in_helper(obj2);
34334 if (arg3 == NULL) SWIG_fail;
34335 temp3 = true;
34336 }
34337 {
34338 PyThreadState* __tstate = wxPyBeginAllowThreads();
34339 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34340
34341 wxPyEndAllowThreads(__tstate);
34342 if (PyErr_Occurred()) SWIG_fail;
34343 }
34344 Py_INCREF(Py_None); resultobj = Py_None;
34345 {
34346 if (temp3)
34347 delete arg3;
34348 }
34349 return resultobj;
34350 fail:
34351 {
34352 if (temp3)
34353 delete arg3;
34354 }
34355 return NULL;
34356 }
34357
34358
34359 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34360 PyObject *resultobj;
34361 wxMenu *arg1 = (wxMenu *) 0 ;
34362 int arg2 ;
34363 wxString result;
34364 PyObject * obj0 = 0 ;
34365 PyObject * obj1 = 0 ;
34366 char *kwnames[] = {
34367 (char *) "self",(char *) "id", NULL
34368 };
34369
34370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34372 if (SWIG_arg_fail(1)) SWIG_fail;
34373 {
34374 arg2 = (int)(SWIG_As_int(obj1));
34375 if (SWIG_arg_fail(2)) SWIG_fail;
34376 }
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34380
34381 wxPyEndAllowThreads(__tstate);
34382 if (PyErr_Occurred()) SWIG_fail;
34383 }
34384 {
34385 #if wxUSE_UNICODE
34386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34387 #else
34388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34389 #endif
34390 }
34391 return resultobj;
34392 fail:
34393 return NULL;
34394 }
34395
34396
34397 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34398 PyObject *resultobj;
34399 wxMenu *arg1 = (wxMenu *) 0 ;
34400 int arg2 ;
34401 wxString *arg3 = 0 ;
34402 bool temp3 = false ;
34403 PyObject * obj0 = 0 ;
34404 PyObject * obj1 = 0 ;
34405 PyObject * obj2 = 0 ;
34406 char *kwnames[] = {
34407 (char *) "self",(char *) "id",(char *) "helpString", NULL
34408 };
34409
34410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34412 if (SWIG_arg_fail(1)) SWIG_fail;
34413 {
34414 arg2 = (int)(SWIG_As_int(obj1));
34415 if (SWIG_arg_fail(2)) SWIG_fail;
34416 }
34417 {
34418 arg3 = wxString_in_helper(obj2);
34419 if (arg3 == NULL) SWIG_fail;
34420 temp3 = true;
34421 }
34422 {
34423 PyThreadState* __tstate = wxPyBeginAllowThreads();
34424 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34425
34426 wxPyEndAllowThreads(__tstate);
34427 if (PyErr_Occurred()) SWIG_fail;
34428 }
34429 Py_INCREF(Py_None); resultobj = Py_None;
34430 {
34431 if (temp3)
34432 delete arg3;
34433 }
34434 return resultobj;
34435 fail:
34436 {
34437 if (temp3)
34438 delete arg3;
34439 }
34440 return NULL;
34441 }
34442
34443
34444 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj;
34446 wxMenu *arg1 = (wxMenu *) 0 ;
34447 int arg2 ;
34448 wxString result;
34449 PyObject * obj0 = 0 ;
34450 PyObject * obj1 = 0 ;
34451 char *kwnames[] = {
34452 (char *) "self",(char *) "id", NULL
34453 };
34454
34455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34457 if (SWIG_arg_fail(1)) SWIG_fail;
34458 {
34459 arg2 = (int)(SWIG_As_int(obj1));
34460 if (SWIG_arg_fail(2)) SWIG_fail;
34461 }
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34465
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 {
34470 #if wxUSE_UNICODE
34471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34472 #else
34473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34474 #endif
34475 }
34476 return resultobj;
34477 fail:
34478 return NULL;
34479 }
34480
34481
34482 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34483 PyObject *resultobj;
34484 wxMenu *arg1 = (wxMenu *) 0 ;
34485 wxString *arg2 = 0 ;
34486 bool temp2 = false ;
34487 PyObject * obj0 = 0 ;
34488 PyObject * obj1 = 0 ;
34489 char *kwnames[] = {
34490 (char *) "self",(char *) "title", NULL
34491 };
34492
34493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34495 if (SWIG_arg_fail(1)) SWIG_fail;
34496 {
34497 arg2 = wxString_in_helper(obj1);
34498 if (arg2 == NULL) SWIG_fail;
34499 temp2 = true;
34500 }
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 (arg1)->SetTitle((wxString const &)*arg2);
34504
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 Py_INCREF(Py_None); resultobj = Py_None;
34509 {
34510 if (temp2)
34511 delete arg2;
34512 }
34513 return resultobj;
34514 fail:
34515 {
34516 if (temp2)
34517 delete arg2;
34518 }
34519 return NULL;
34520 }
34521
34522
34523 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34524 PyObject *resultobj;
34525 wxMenu *arg1 = (wxMenu *) 0 ;
34526 wxString result;
34527 PyObject * obj0 = 0 ;
34528 char *kwnames[] = {
34529 (char *) "self", NULL
34530 };
34531
34532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34534 if (SWIG_arg_fail(1)) SWIG_fail;
34535 {
34536 PyThreadState* __tstate = wxPyBeginAllowThreads();
34537 result = ((wxMenu const *)arg1)->GetTitle();
34538
34539 wxPyEndAllowThreads(__tstate);
34540 if (PyErr_Occurred()) SWIG_fail;
34541 }
34542 {
34543 #if wxUSE_UNICODE
34544 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34545 #else
34546 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34547 #endif
34548 }
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34556 PyObject *resultobj;
34557 wxMenu *arg1 = (wxMenu *) 0 ;
34558 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34559 PyObject * obj0 = 0 ;
34560 PyObject * obj1 = 0 ;
34561 char *kwnames[] = {
34562 (char *) "self",(char *) "handler", NULL
34563 };
34564
34565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34567 if (SWIG_arg_fail(1)) SWIG_fail;
34568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34569 if (SWIG_arg_fail(2)) SWIG_fail;
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 (arg1)->SetEventHandler(arg2);
34573
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 Py_INCREF(Py_None); resultobj = Py_None;
34578 return resultobj;
34579 fail:
34580 return NULL;
34581 }
34582
34583
34584 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34585 PyObject *resultobj;
34586 wxMenu *arg1 = (wxMenu *) 0 ;
34587 wxEvtHandler *result;
34588 PyObject * obj0 = 0 ;
34589 char *kwnames[] = {
34590 (char *) "self", NULL
34591 };
34592
34593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34595 if (SWIG_arg_fail(1)) SWIG_fail;
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34599
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 {
34604 resultobj = wxPyMake_wxObject(result, 0);
34605 }
34606 return resultobj;
34607 fail:
34608 return NULL;
34609 }
34610
34611
34612 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34613 PyObject *resultobj;
34614 wxMenu *arg1 = (wxMenu *) 0 ;
34615 wxWindow *arg2 = (wxWindow *) 0 ;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 char *kwnames[] = {
34619 (char *) "self",(char *) "win", NULL
34620 };
34621
34622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34624 if (SWIG_arg_fail(1)) SWIG_fail;
34625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34626 if (SWIG_arg_fail(2)) SWIG_fail;
34627 {
34628 PyThreadState* __tstate = wxPyBeginAllowThreads();
34629 (arg1)->SetInvokingWindow(arg2);
34630
34631 wxPyEndAllowThreads(__tstate);
34632 if (PyErr_Occurred()) SWIG_fail;
34633 }
34634 Py_INCREF(Py_None); resultobj = Py_None;
34635 return resultobj;
34636 fail:
34637 return NULL;
34638 }
34639
34640
34641 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34642 PyObject *resultobj;
34643 wxMenu *arg1 = (wxMenu *) 0 ;
34644 wxWindow *result;
34645 PyObject * obj0 = 0 ;
34646 char *kwnames[] = {
34647 (char *) "self", NULL
34648 };
34649
34650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34652 if (SWIG_arg_fail(1)) SWIG_fail;
34653 {
34654 PyThreadState* __tstate = wxPyBeginAllowThreads();
34655 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34656
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 {
34661 resultobj = wxPyMake_wxObject(result, 0);
34662 }
34663 return resultobj;
34664 fail:
34665 return NULL;
34666 }
34667
34668
34669 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34670 PyObject *resultobj;
34671 wxMenu *arg1 = (wxMenu *) 0 ;
34672 long result;
34673 PyObject * obj0 = 0 ;
34674 char *kwnames[] = {
34675 (char *) "self", NULL
34676 };
34677
34678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34680 if (SWIG_arg_fail(1)) SWIG_fail;
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (long)((wxMenu const *)arg1)->GetStyle();
34684
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 {
34689 resultobj = SWIG_From_long((long)(result));
34690 }
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34698 PyObject *resultobj;
34699 wxMenu *arg1 = (wxMenu *) 0 ;
34700 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char *kwnames[] = {
34704 (char *) "self",(char *) "source", NULL
34705 };
34706
34707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34709 if (SWIG_arg_fail(1)) SWIG_fail;
34710 if (obj1) {
34711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34712 if (SWIG_arg_fail(2)) SWIG_fail;
34713 }
34714 {
34715 PyThreadState* __tstate = wxPyBeginAllowThreads();
34716 (arg1)->UpdateUI(arg2);
34717
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 Py_INCREF(Py_None); resultobj = Py_None;
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34729 PyObject *resultobj;
34730 wxMenu *arg1 = (wxMenu *) 0 ;
34731 wxMenuBar *result;
34732 PyObject * obj0 = 0 ;
34733 char *kwnames[] = {
34734 (char *) "self", NULL
34735 };
34736
34737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34739 if (SWIG_arg_fail(1)) SWIG_fail;
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34743
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 {
34748 resultobj = wxPyMake_wxObject(result, 0);
34749 }
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34757 PyObject *resultobj;
34758 wxMenu *arg1 = (wxMenu *) 0 ;
34759 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34760 PyObject * obj0 = 0 ;
34761 PyObject * obj1 = 0 ;
34762 char *kwnames[] = {
34763 (char *) "self",(char *) "menubar", NULL
34764 };
34765
34766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34768 if (SWIG_arg_fail(1)) SWIG_fail;
34769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34770 if (SWIG_arg_fail(2)) SWIG_fail;
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 (arg1)->Attach(arg2);
34774
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 Py_INCREF(Py_None); resultobj = Py_None;
34779 return resultobj;
34780 fail:
34781 return NULL;
34782 }
34783
34784
34785 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34786 PyObject *resultobj;
34787 wxMenu *arg1 = (wxMenu *) 0 ;
34788 PyObject * obj0 = 0 ;
34789 char *kwnames[] = {
34790 (char *) "self", NULL
34791 };
34792
34793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34795 if (SWIG_arg_fail(1)) SWIG_fail;
34796 {
34797 PyThreadState* __tstate = wxPyBeginAllowThreads();
34798 (arg1)->Detach();
34799
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 Py_INCREF(Py_None); resultobj = Py_None;
34804 return resultobj;
34805 fail:
34806 return NULL;
34807 }
34808
34809
34810 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34811 PyObject *resultobj;
34812 wxMenu *arg1 = (wxMenu *) 0 ;
34813 bool result;
34814 PyObject * obj0 = 0 ;
34815 char *kwnames[] = {
34816 (char *) "self", NULL
34817 };
34818
34819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34821 if (SWIG_arg_fail(1)) SWIG_fail;
34822 {
34823 PyThreadState* __tstate = wxPyBeginAllowThreads();
34824 result = (bool)((wxMenu const *)arg1)->IsAttached();
34825
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 {
34830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj;
34840 wxMenu *arg1 = (wxMenu *) 0 ;
34841 wxMenu *arg2 = (wxMenu *) 0 ;
34842 PyObject * obj0 = 0 ;
34843 PyObject * obj1 = 0 ;
34844 char *kwnames[] = {
34845 (char *) "self",(char *) "parent", NULL
34846 };
34847
34848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34850 if (SWIG_arg_fail(1)) SWIG_fail;
34851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34852 if (SWIG_arg_fail(2)) SWIG_fail;
34853 {
34854 PyThreadState* __tstate = wxPyBeginAllowThreads();
34855 (arg1)->SetParent(arg2);
34856
34857 wxPyEndAllowThreads(__tstate);
34858 if (PyErr_Occurred()) SWIG_fail;
34859 }
34860 Py_INCREF(Py_None); resultobj = Py_None;
34861 return resultobj;
34862 fail:
34863 return NULL;
34864 }
34865
34866
34867 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34868 PyObject *resultobj;
34869 wxMenu *arg1 = (wxMenu *) 0 ;
34870 wxMenu *result;
34871 PyObject * obj0 = 0 ;
34872 char *kwnames[] = {
34873 (char *) "self", NULL
34874 };
34875
34876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34878 if (SWIG_arg_fail(1)) SWIG_fail;
34879 {
34880 PyThreadState* __tstate = wxPyBeginAllowThreads();
34881 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34882
34883 wxPyEndAllowThreads(__tstate);
34884 if (PyErr_Occurred()) SWIG_fail;
34885 }
34886 {
34887 resultobj = wxPyMake_wxObject(result, 0);
34888 }
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34896 PyObject *obj;
34897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34898 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34899 Py_INCREF(obj);
34900 return Py_BuildValue((char *)"");
34901 }
34902 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj;
34904 long arg1 = (long) 0 ;
34905 wxMenuBar *result;
34906 PyObject * obj0 = 0 ;
34907 char *kwnames[] = {
34908 (char *) "style", NULL
34909 };
34910
34911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34912 if (obj0) {
34913 {
34914 arg1 = (long)(SWIG_As_long(obj0));
34915 if (SWIG_arg_fail(1)) SWIG_fail;
34916 }
34917 }
34918 {
34919 if (!wxPyCheckForApp()) SWIG_fail;
34920 PyThreadState* __tstate = wxPyBeginAllowThreads();
34921 result = (wxMenuBar *)new wxMenuBar(arg1);
34922
34923 wxPyEndAllowThreads(__tstate);
34924 if (PyErr_Occurred()) SWIG_fail;
34925 }
34926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34927 return resultobj;
34928 fail:
34929 return NULL;
34930 }
34931
34932
34933 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34934 PyObject *resultobj;
34935 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34936 wxMenu *arg2 = (wxMenu *) 0 ;
34937 wxString *arg3 = 0 ;
34938 bool result;
34939 bool temp3 = false ;
34940 PyObject * obj0 = 0 ;
34941 PyObject * obj1 = 0 ;
34942 PyObject * obj2 = 0 ;
34943 char *kwnames[] = {
34944 (char *) "self",(char *) "menu",(char *) "title", NULL
34945 };
34946
34947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34949 if (SWIG_arg_fail(1)) SWIG_fail;
34950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34951 if (SWIG_arg_fail(2)) SWIG_fail;
34952 {
34953 arg3 = wxString_in_helper(obj2);
34954 if (arg3 == NULL) SWIG_fail;
34955 temp3 = true;
34956 }
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34960
34961 wxPyEndAllowThreads(__tstate);
34962 if (PyErr_Occurred()) SWIG_fail;
34963 }
34964 {
34965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34966 }
34967 {
34968 if (temp3)
34969 delete arg3;
34970 }
34971 return resultobj;
34972 fail:
34973 {
34974 if (temp3)
34975 delete arg3;
34976 }
34977 return NULL;
34978 }
34979
34980
34981 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34982 PyObject *resultobj;
34983 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34984 size_t arg2 ;
34985 wxMenu *arg3 = (wxMenu *) 0 ;
34986 wxString *arg4 = 0 ;
34987 bool result;
34988 bool temp4 = false ;
34989 PyObject * obj0 = 0 ;
34990 PyObject * obj1 = 0 ;
34991 PyObject * obj2 = 0 ;
34992 PyObject * obj3 = 0 ;
34993 char *kwnames[] = {
34994 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34995 };
34996
34997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34999 if (SWIG_arg_fail(1)) SWIG_fail;
35000 {
35001 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35002 if (SWIG_arg_fail(2)) SWIG_fail;
35003 }
35004 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35005 if (SWIG_arg_fail(3)) SWIG_fail;
35006 {
35007 arg4 = wxString_in_helper(obj3);
35008 if (arg4 == NULL) SWIG_fail;
35009 temp4 = true;
35010 }
35011 {
35012 PyThreadState* __tstate = wxPyBeginAllowThreads();
35013 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35014
35015 wxPyEndAllowThreads(__tstate);
35016 if (PyErr_Occurred()) SWIG_fail;
35017 }
35018 {
35019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35020 }
35021 {
35022 if (temp4)
35023 delete arg4;
35024 }
35025 return resultobj;
35026 fail:
35027 {
35028 if (temp4)
35029 delete arg4;
35030 }
35031 return NULL;
35032 }
35033
35034
35035 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj;
35037 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35038 size_t result;
35039 PyObject * obj0 = 0 ;
35040 char *kwnames[] = {
35041 (char *) "self", NULL
35042 };
35043
35044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35046 if (SWIG_arg_fail(1)) SWIG_fail;
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35050
35051 wxPyEndAllowThreads(__tstate);
35052 if (PyErr_Occurred()) SWIG_fail;
35053 }
35054 {
35055 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35056 }
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35064 PyObject *resultobj;
35065 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35066 size_t arg2 ;
35067 wxMenu *result;
35068 PyObject * obj0 = 0 ;
35069 PyObject * obj1 = 0 ;
35070 char *kwnames[] = {
35071 (char *) "self",(char *) "pos", NULL
35072 };
35073
35074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35076 if (SWIG_arg_fail(1)) SWIG_fail;
35077 {
35078 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35079 if (SWIG_arg_fail(2)) SWIG_fail;
35080 }
35081 {
35082 PyThreadState* __tstate = wxPyBeginAllowThreads();
35083 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35084
35085 wxPyEndAllowThreads(__tstate);
35086 if (PyErr_Occurred()) SWIG_fail;
35087 }
35088 {
35089 resultobj = wxPyMake_wxObject(result, 0);
35090 }
35091 return resultobj;
35092 fail:
35093 return NULL;
35094 }
35095
35096
35097 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35098 PyObject *resultobj;
35099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35100 size_t arg2 ;
35101 wxMenu *arg3 = (wxMenu *) 0 ;
35102 wxString *arg4 = 0 ;
35103 wxMenu *result;
35104 bool temp4 = false ;
35105 PyObject * obj0 = 0 ;
35106 PyObject * obj1 = 0 ;
35107 PyObject * obj2 = 0 ;
35108 PyObject * obj3 = 0 ;
35109 char *kwnames[] = {
35110 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35111 };
35112
35113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35115 if (SWIG_arg_fail(1)) SWIG_fail;
35116 {
35117 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35118 if (SWIG_arg_fail(2)) SWIG_fail;
35119 }
35120 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35121 if (SWIG_arg_fail(3)) SWIG_fail;
35122 {
35123 arg4 = wxString_in_helper(obj3);
35124 if (arg4 == NULL) SWIG_fail;
35125 temp4 = true;
35126 }
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35130
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 {
35135 resultobj = wxPyMake_wxObject(result, 0);
35136 }
35137 {
35138 if (temp4)
35139 delete arg4;
35140 }
35141 return resultobj;
35142 fail:
35143 {
35144 if (temp4)
35145 delete arg4;
35146 }
35147 return NULL;
35148 }
35149
35150
35151 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35152 PyObject *resultobj;
35153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35154 size_t arg2 ;
35155 wxMenu *result;
35156 PyObject * obj0 = 0 ;
35157 PyObject * obj1 = 0 ;
35158 char *kwnames[] = {
35159 (char *) "self",(char *) "pos", NULL
35160 };
35161
35162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35164 if (SWIG_arg_fail(1)) SWIG_fail;
35165 {
35166 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35167 if (SWIG_arg_fail(2)) SWIG_fail;
35168 }
35169 {
35170 PyThreadState* __tstate = wxPyBeginAllowThreads();
35171 result = (wxMenu *)(arg1)->Remove(arg2);
35172
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 {
35177 resultobj = wxPyMake_wxObject(result, 0);
35178 }
35179 return resultobj;
35180 fail:
35181 return NULL;
35182 }
35183
35184
35185 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35186 PyObject *resultobj;
35187 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35188 size_t arg2 ;
35189 bool arg3 ;
35190 PyObject * obj0 = 0 ;
35191 PyObject * obj1 = 0 ;
35192 PyObject * obj2 = 0 ;
35193 char *kwnames[] = {
35194 (char *) "self",(char *) "pos",(char *) "enable", NULL
35195 };
35196
35197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = (bool)(SWIG_As_bool(obj2));
35206 if (SWIG_arg_fail(3)) SWIG_fail;
35207 }
35208 {
35209 PyThreadState* __tstate = wxPyBeginAllowThreads();
35210 (arg1)->EnableTop(arg2,arg3);
35211
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 Py_INCREF(Py_None); resultobj = Py_None;
35216 return resultobj;
35217 fail:
35218 return NULL;
35219 }
35220
35221
35222 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35223 PyObject *resultobj;
35224 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35225 size_t arg2 ;
35226 bool result;
35227 PyObject * obj0 = 0 ;
35228 PyObject * obj1 = 0 ;
35229 char *kwnames[] = {
35230 (char *) "self",(char *) "pos", NULL
35231 };
35232
35233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35235 if (SWIG_arg_fail(1)) SWIG_fail;
35236 {
35237 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35238 if (SWIG_arg_fail(2)) SWIG_fail;
35239 }
35240 {
35241 PyThreadState* __tstate = wxPyBeginAllowThreads();
35242 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35243
35244 wxPyEndAllowThreads(__tstate);
35245 if (PyErr_Occurred()) SWIG_fail;
35246 }
35247 {
35248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35249 }
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj;
35258 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35259 size_t arg2 ;
35260 wxString *arg3 = 0 ;
35261 bool temp3 = false ;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 PyObject * obj2 = 0 ;
35265 char *kwnames[] = {
35266 (char *) "self",(char *) "pos",(char *) "label", NULL
35267 };
35268
35269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35271 if (SWIG_arg_fail(1)) SWIG_fail;
35272 {
35273 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35274 if (SWIG_arg_fail(2)) SWIG_fail;
35275 }
35276 {
35277 arg3 = wxString_in_helper(obj2);
35278 if (arg3 == NULL) SWIG_fail;
35279 temp3 = true;
35280 }
35281 {
35282 PyThreadState* __tstate = wxPyBeginAllowThreads();
35283 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35284
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 Py_INCREF(Py_None); resultobj = Py_None;
35289 {
35290 if (temp3)
35291 delete arg3;
35292 }
35293 return resultobj;
35294 fail:
35295 {
35296 if (temp3)
35297 delete arg3;
35298 }
35299 return NULL;
35300 }
35301
35302
35303 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35304 PyObject *resultobj;
35305 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35306 size_t arg2 ;
35307 wxString result;
35308 PyObject * obj0 = 0 ;
35309 PyObject * obj1 = 0 ;
35310 char *kwnames[] = {
35311 (char *) "self",(char *) "pos", NULL
35312 };
35313
35314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35316 if (SWIG_arg_fail(1)) SWIG_fail;
35317 {
35318 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35319 if (SWIG_arg_fail(2)) SWIG_fail;
35320 }
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35324
35325 wxPyEndAllowThreads(__tstate);
35326 if (PyErr_Occurred()) SWIG_fail;
35327 }
35328 {
35329 #if wxUSE_UNICODE
35330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35331 #else
35332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35333 #endif
35334 }
35335 return resultobj;
35336 fail:
35337 return NULL;
35338 }
35339
35340
35341 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35342 PyObject *resultobj;
35343 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35344 wxString *arg2 = 0 ;
35345 wxString *arg3 = 0 ;
35346 int result;
35347 bool temp2 = false ;
35348 bool temp3 = false ;
35349 PyObject * obj0 = 0 ;
35350 PyObject * obj1 = 0 ;
35351 PyObject * obj2 = 0 ;
35352 char *kwnames[] = {
35353 (char *) "self",(char *) "menu",(char *) "item", NULL
35354 };
35355
35356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35358 if (SWIG_arg_fail(1)) SWIG_fail;
35359 {
35360 arg2 = wxString_in_helper(obj1);
35361 if (arg2 == NULL) SWIG_fail;
35362 temp2 = true;
35363 }
35364 {
35365 arg3 = wxString_in_helper(obj2);
35366 if (arg3 == NULL) SWIG_fail;
35367 temp3 = true;
35368 }
35369 {
35370 PyThreadState* __tstate = wxPyBeginAllowThreads();
35371 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35372
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 {
35377 resultobj = SWIG_From_int((int)(result));
35378 }
35379 {
35380 if (temp2)
35381 delete arg2;
35382 }
35383 {
35384 if (temp3)
35385 delete arg3;
35386 }
35387 return resultobj;
35388 fail:
35389 {
35390 if (temp2)
35391 delete arg2;
35392 }
35393 {
35394 if (temp3)
35395 delete arg3;
35396 }
35397 return NULL;
35398 }
35399
35400
35401 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35402 PyObject *resultobj;
35403 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35404 int arg2 ;
35405 wxMenuItem *result;
35406 PyObject * obj0 = 0 ;
35407 PyObject * obj1 = 0 ;
35408 char *kwnames[] = {
35409 (char *) "self",(char *) "id", NULL
35410 };
35411
35412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35414 if (SWIG_arg_fail(1)) SWIG_fail;
35415 {
35416 arg2 = (int)(SWIG_As_int(obj1));
35417 if (SWIG_arg_fail(2)) SWIG_fail;
35418 }
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35422
35423 wxPyEndAllowThreads(__tstate);
35424 if (PyErr_Occurred()) SWIG_fail;
35425 }
35426 {
35427 resultobj = wxPyMake_wxObject(result, 0);
35428 }
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35436 PyObject *resultobj;
35437 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35438 wxString *arg2 = 0 ;
35439 int result;
35440 bool temp2 = false ;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char *kwnames[] = {
35444 (char *) "self",(char *) "title", NULL
35445 };
35446
35447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",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 = wxString_in_helper(obj1);
35452 if (arg2 == NULL) SWIG_fail;
35453 temp2 = true;
35454 }
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35458
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 {
35463 resultobj = SWIG_From_int((int)(result));
35464 }
35465 {
35466 if (temp2)
35467 delete arg2;
35468 }
35469 return resultobj;
35470 fail:
35471 {
35472 if (temp2)
35473 delete arg2;
35474 }
35475 return NULL;
35476 }
35477
35478
35479 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35480 PyObject *resultobj;
35481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35482 int arg2 ;
35483 bool arg3 ;
35484 PyObject * obj0 = 0 ;
35485 PyObject * obj1 = 0 ;
35486 PyObject * obj2 = 0 ;
35487 char *kwnames[] = {
35488 (char *) "self",(char *) "id",(char *) "enable", NULL
35489 };
35490
35491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35493 if (SWIG_arg_fail(1)) SWIG_fail;
35494 {
35495 arg2 = (int)(SWIG_As_int(obj1));
35496 if (SWIG_arg_fail(2)) SWIG_fail;
35497 }
35498 {
35499 arg3 = (bool)(SWIG_As_bool(obj2));
35500 if (SWIG_arg_fail(3)) SWIG_fail;
35501 }
35502 {
35503 PyThreadState* __tstate = wxPyBeginAllowThreads();
35504 (arg1)->Enable(arg2,arg3);
35505
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 Py_INCREF(Py_None); resultobj = Py_None;
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35517 PyObject *resultobj;
35518 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35519 int arg2 ;
35520 bool arg3 ;
35521 PyObject * obj0 = 0 ;
35522 PyObject * obj1 = 0 ;
35523 PyObject * obj2 = 0 ;
35524 char *kwnames[] = {
35525 (char *) "self",(char *) "id",(char *) "check", NULL
35526 };
35527
35528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35530 if (SWIG_arg_fail(1)) SWIG_fail;
35531 {
35532 arg2 = (int)(SWIG_As_int(obj1));
35533 if (SWIG_arg_fail(2)) SWIG_fail;
35534 }
35535 {
35536 arg3 = (bool)(SWIG_As_bool(obj2));
35537 if (SWIG_arg_fail(3)) SWIG_fail;
35538 }
35539 {
35540 PyThreadState* __tstate = wxPyBeginAllowThreads();
35541 (arg1)->Check(arg2,arg3);
35542
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 Py_INCREF(Py_None); resultobj = Py_None;
35547 return resultobj;
35548 fail:
35549 return NULL;
35550 }
35551
35552
35553 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35554 PyObject *resultobj;
35555 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35556 int arg2 ;
35557 bool result;
35558 PyObject * obj0 = 0 ;
35559 PyObject * obj1 = 0 ;
35560 char *kwnames[] = {
35561 (char *) "self",(char *) "id", NULL
35562 };
35563
35564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35566 if (SWIG_arg_fail(1)) SWIG_fail;
35567 {
35568 arg2 = (int)(SWIG_As_int(obj1));
35569 if (SWIG_arg_fail(2)) SWIG_fail;
35570 }
35571 {
35572 PyThreadState* __tstate = wxPyBeginAllowThreads();
35573 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35574
35575 wxPyEndAllowThreads(__tstate);
35576 if (PyErr_Occurred()) SWIG_fail;
35577 }
35578 {
35579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35580 }
35581 return resultobj;
35582 fail:
35583 return NULL;
35584 }
35585
35586
35587 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35588 PyObject *resultobj;
35589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35590 int arg2 ;
35591 bool result;
35592 PyObject * obj0 = 0 ;
35593 PyObject * obj1 = 0 ;
35594 char *kwnames[] = {
35595 (char *) "self",(char *) "id", NULL
35596 };
35597
35598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35600 if (SWIG_arg_fail(1)) SWIG_fail;
35601 {
35602 arg2 = (int)(SWIG_As_int(obj1));
35603 if (SWIG_arg_fail(2)) SWIG_fail;
35604 }
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35608
35609 wxPyEndAllowThreads(__tstate);
35610 if (PyErr_Occurred()) SWIG_fail;
35611 }
35612 {
35613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35614 }
35615 return resultobj;
35616 fail:
35617 return NULL;
35618 }
35619
35620
35621 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj;
35623 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35624 int arg2 ;
35625 wxString *arg3 = 0 ;
35626 bool temp3 = false ;
35627 PyObject * obj0 = 0 ;
35628 PyObject * obj1 = 0 ;
35629 PyObject * obj2 = 0 ;
35630 char *kwnames[] = {
35631 (char *) "self",(char *) "id",(char *) "label", NULL
35632 };
35633
35634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35636 if (SWIG_arg_fail(1)) SWIG_fail;
35637 {
35638 arg2 = (int)(SWIG_As_int(obj1));
35639 if (SWIG_arg_fail(2)) SWIG_fail;
35640 }
35641 {
35642 arg3 = wxString_in_helper(obj2);
35643 if (arg3 == NULL) SWIG_fail;
35644 temp3 = true;
35645 }
35646 {
35647 PyThreadState* __tstate = wxPyBeginAllowThreads();
35648 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35649
35650 wxPyEndAllowThreads(__tstate);
35651 if (PyErr_Occurred()) SWIG_fail;
35652 }
35653 Py_INCREF(Py_None); resultobj = Py_None;
35654 {
35655 if (temp3)
35656 delete arg3;
35657 }
35658 return resultobj;
35659 fail:
35660 {
35661 if (temp3)
35662 delete arg3;
35663 }
35664 return NULL;
35665 }
35666
35667
35668 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35669 PyObject *resultobj;
35670 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35671 int arg2 ;
35672 wxString result;
35673 PyObject * obj0 = 0 ;
35674 PyObject * obj1 = 0 ;
35675 char *kwnames[] = {
35676 (char *) "self",(char *) "id", NULL
35677 };
35678
35679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35681 if (SWIG_arg_fail(1)) SWIG_fail;
35682 {
35683 arg2 = (int)(SWIG_As_int(obj1));
35684 if (SWIG_arg_fail(2)) SWIG_fail;
35685 }
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35689
35690 wxPyEndAllowThreads(__tstate);
35691 if (PyErr_Occurred()) SWIG_fail;
35692 }
35693 {
35694 #if wxUSE_UNICODE
35695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35696 #else
35697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35698 #endif
35699 }
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35707 PyObject *resultobj;
35708 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35709 int arg2 ;
35710 wxString *arg3 = 0 ;
35711 bool temp3 = false ;
35712 PyObject * obj0 = 0 ;
35713 PyObject * obj1 = 0 ;
35714 PyObject * obj2 = 0 ;
35715 char *kwnames[] = {
35716 (char *) "self",(char *) "id",(char *) "helpString", NULL
35717 };
35718
35719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35721 if (SWIG_arg_fail(1)) SWIG_fail;
35722 {
35723 arg2 = (int)(SWIG_As_int(obj1));
35724 if (SWIG_arg_fail(2)) SWIG_fail;
35725 }
35726 {
35727 arg3 = wxString_in_helper(obj2);
35728 if (arg3 == NULL) SWIG_fail;
35729 temp3 = true;
35730 }
35731 {
35732 PyThreadState* __tstate = wxPyBeginAllowThreads();
35733 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35734
35735 wxPyEndAllowThreads(__tstate);
35736 if (PyErr_Occurred()) SWIG_fail;
35737 }
35738 Py_INCREF(Py_None); resultobj = Py_None;
35739 {
35740 if (temp3)
35741 delete arg3;
35742 }
35743 return resultobj;
35744 fail:
35745 {
35746 if (temp3)
35747 delete arg3;
35748 }
35749 return NULL;
35750 }
35751
35752
35753 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35754 PyObject *resultobj;
35755 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35756 int arg2 ;
35757 wxString result;
35758 PyObject * obj0 = 0 ;
35759 PyObject * obj1 = 0 ;
35760 char *kwnames[] = {
35761 (char *) "self",(char *) "id", NULL
35762 };
35763
35764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35766 if (SWIG_arg_fail(1)) SWIG_fail;
35767 {
35768 arg2 = (int)(SWIG_As_int(obj1));
35769 if (SWIG_arg_fail(2)) SWIG_fail;
35770 }
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35774
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 {
35779 #if wxUSE_UNICODE
35780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35781 #else
35782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35783 #endif
35784 }
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35792 PyObject *resultobj;
35793 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35794 wxFrame *result;
35795 PyObject * obj0 = 0 ;
35796 char *kwnames[] = {
35797 (char *) "self", NULL
35798 };
35799
35800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35802 if (SWIG_arg_fail(1)) SWIG_fail;
35803 {
35804 PyThreadState* __tstate = wxPyBeginAllowThreads();
35805 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35806
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 {
35811 resultobj = wxPyMake_wxObject(result, 0);
35812 }
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj;
35821 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35822 bool result;
35823 PyObject * obj0 = 0 ;
35824 char *kwnames[] = {
35825 (char *) "self", NULL
35826 };
35827
35828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35830 if (SWIG_arg_fail(1)) SWIG_fail;
35831 {
35832 PyThreadState* __tstate = wxPyBeginAllowThreads();
35833 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35834
35835 wxPyEndAllowThreads(__tstate);
35836 if (PyErr_Occurred()) SWIG_fail;
35837 }
35838 {
35839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35840 }
35841 return resultobj;
35842 fail:
35843 return NULL;
35844 }
35845
35846
35847 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35848 PyObject *resultobj;
35849 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35850 wxFrame *arg2 = (wxFrame *) 0 ;
35851 PyObject * obj0 = 0 ;
35852 PyObject * obj1 = 0 ;
35853 char *kwnames[] = {
35854 (char *) "self",(char *) "frame", NULL
35855 };
35856
35857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35859 if (SWIG_arg_fail(1)) SWIG_fail;
35860 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35861 if (SWIG_arg_fail(2)) SWIG_fail;
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 (arg1)->Attach(arg2);
35865
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 Py_INCREF(Py_None); resultobj = Py_None;
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35877 PyObject *resultobj;
35878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35879 PyObject * obj0 = 0 ;
35880 char *kwnames[] = {
35881 (char *) "self", NULL
35882 };
35883
35884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35886 if (SWIG_arg_fail(1)) SWIG_fail;
35887 {
35888 PyThreadState* __tstate = wxPyBeginAllowThreads();
35889 (arg1)->Detach();
35890
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 Py_INCREF(Py_None); resultobj = Py_None;
35895 return resultobj;
35896 fail:
35897 return NULL;
35898 }
35899
35900
35901 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35902 PyObject *obj;
35903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35904 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35905 Py_INCREF(obj);
35906 return Py_BuildValue((char *)"");
35907 }
35908 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35909 PyObject *resultobj;
35910 wxMenu *arg1 = (wxMenu *) NULL ;
35911 int arg2 = (int) wxID_ANY ;
35912 wxString const &arg3_defvalue = wxPyEmptyString ;
35913 wxString *arg3 = (wxString *) &arg3_defvalue ;
35914 wxString const &arg4_defvalue = wxPyEmptyString ;
35915 wxString *arg4 = (wxString *) &arg4_defvalue ;
35916 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35917 wxMenu *arg6 = (wxMenu *) NULL ;
35918 wxMenuItem *result;
35919 bool temp3 = false ;
35920 bool temp4 = false ;
35921 PyObject * obj0 = 0 ;
35922 PyObject * obj1 = 0 ;
35923 PyObject * obj2 = 0 ;
35924 PyObject * obj3 = 0 ;
35925 PyObject * obj4 = 0 ;
35926 PyObject * obj5 = 0 ;
35927 char *kwnames[] = {
35928 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35929 };
35930
35931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35932 if (obj0) {
35933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35934 if (SWIG_arg_fail(1)) SWIG_fail;
35935 }
35936 if (obj1) {
35937 {
35938 arg2 = (int)(SWIG_As_int(obj1));
35939 if (SWIG_arg_fail(2)) SWIG_fail;
35940 }
35941 }
35942 if (obj2) {
35943 {
35944 arg3 = wxString_in_helper(obj2);
35945 if (arg3 == NULL) SWIG_fail;
35946 temp3 = true;
35947 }
35948 }
35949 if (obj3) {
35950 {
35951 arg4 = wxString_in_helper(obj3);
35952 if (arg4 == NULL) SWIG_fail;
35953 temp4 = true;
35954 }
35955 }
35956 if (obj4) {
35957 {
35958 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35959 if (SWIG_arg_fail(5)) SWIG_fail;
35960 }
35961 }
35962 if (obj5) {
35963 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35964 if (SWIG_arg_fail(6)) SWIG_fail;
35965 }
35966 {
35967 PyThreadState* __tstate = wxPyBeginAllowThreads();
35968 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35969
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 {
35974 resultobj = wxPyMake_wxObject(result, 1);
35975 }
35976 {
35977 if (temp3)
35978 delete arg3;
35979 }
35980 {
35981 if (temp4)
35982 delete arg4;
35983 }
35984 return resultobj;
35985 fail:
35986 {
35987 if (temp3)
35988 delete arg3;
35989 }
35990 {
35991 if (temp4)
35992 delete arg4;
35993 }
35994 return NULL;
35995 }
35996
35997
35998 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35999 PyObject *resultobj;
36000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36001 wxMenu *result;
36002 PyObject * obj0 = 0 ;
36003 char *kwnames[] = {
36004 (char *) "self", NULL
36005 };
36006
36007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36009 if (SWIG_arg_fail(1)) SWIG_fail;
36010 {
36011 PyThreadState* __tstate = wxPyBeginAllowThreads();
36012 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36013
36014 wxPyEndAllowThreads(__tstate);
36015 if (PyErr_Occurred()) SWIG_fail;
36016 }
36017 {
36018 resultobj = wxPyMake_wxObject(result, 0);
36019 }
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36027 PyObject *resultobj;
36028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36029 wxMenu *arg2 = (wxMenu *) 0 ;
36030 PyObject * obj0 = 0 ;
36031 PyObject * obj1 = 0 ;
36032 char *kwnames[] = {
36033 (char *) "self",(char *) "menu", NULL
36034 };
36035
36036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36038 if (SWIG_arg_fail(1)) SWIG_fail;
36039 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36040 if (SWIG_arg_fail(2)) SWIG_fail;
36041 {
36042 PyThreadState* __tstate = wxPyBeginAllowThreads();
36043 (arg1)->SetMenu(arg2);
36044
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 Py_INCREF(Py_None); resultobj = Py_None;
36049 return resultobj;
36050 fail:
36051 return NULL;
36052 }
36053
36054
36055 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36056 PyObject *resultobj;
36057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36058 int arg2 ;
36059 PyObject * obj0 = 0 ;
36060 PyObject * obj1 = 0 ;
36061 char *kwnames[] = {
36062 (char *) "self",(char *) "id", NULL
36063 };
36064
36065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36067 if (SWIG_arg_fail(1)) SWIG_fail;
36068 {
36069 arg2 = (int)(SWIG_As_int(obj1));
36070 if (SWIG_arg_fail(2)) SWIG_fail;
36071 }
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 (arg1)->SetId(arg2);
36075
36076 wxPyEndAllowThreads(__tstate);
36077 if (PyErr_Occurred()) SWIG_fail;
36078 }
36079 Py_INCREF(Py_None); resultobj = Py_None;
36080 return resultobj;
36081 fail:
36082 return NULL;
36083 }
36084
36085
36086 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36087 PyObject *resultobj;
36088 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36089 int result;
36090 PyObject * obj0 = 0 ;
36091 char *kwnames[] = {
36092 (char *) "self", NULL
36093 };
36094
36095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36097 if (SWIG_arg_fail(1)) SWIG_fail;
36098 {
36099 PyThreadState* __tstate = wxPyBeginAllowThreads();
36100 result = (int)((wxMenuItem const *)arg1)->GetId();
36101
36102 wxPyEndAllowThreads(__tstate);
36103 if (PyErr_Occurred()) SWIG_fail;
36104 }
36105 {
36106 resultobj = SWIG_From_int((int)(result));
36107 }
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36115 PyObject *resultobj;
36116 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36117 bool result;
36118 PyObject * obj0 = 0 ;
36119 char *kwnames[] = {
36120 (char *) "self", NULL
36121 };
36122
36123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36125 if (SWIG_arg_fail(1)) SWIG_fail;
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36129
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 {
36134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36135 }
36136 return resultobj;
36137 fail:
36138 return NULL;
36139 }
36140
36141
36142 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36143 PyObject *resultobj;
36144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36145 wxString *arg2 = 0 ;
36146 bool temp2 = false ;
36147 PyObject * obj0 = 0 ;
36148 PyObject * obj1 = 0 ;
36149 char *kwnames[] = {
36150 (char *) "self",(char *) "str", NULL
36151 };
36152
36153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36155 if (SWIG_arg_fail(1)) SWIG_fail;
36156 {
36157 arg2 = wxString_in_helper(obj1);
36158 if (arg2 == NULL) SWIG_fail;
36159 temp2 = true;
36160 }
36161 {
36162 PyThreadState* __tstate = wxPyBeginAllowThreads();
36163 (arg1)->SetText((wxString const &)*arg2);
36164
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 Py_INCREF(Py_None); resultobj = Py_None;
36169 {
36170 if (temp2)
36171 delete arg2;
36172 }
36173 return resultobj;
36174 fail:
36175 {
36176 if (temp2)
36177 delete arg2;
36178 }
36179 return NULL;
36180 }
36181
36182
36183 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36184 PyObject *resultobj;
36185 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36186 wxString result;
36187 PyObject * obj0 = 0 ;
36188 char *kwnames[] = {
36189 (char *) "self", NULL
36190 };
36191
36192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36194 if (SWIG_arg_fail(1)) SWIG_fail;
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = ((wxMenuItem const *)arg1)->GetLabel();
36198
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 {
36203 #if wxUSE_UNICODE
36204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36205 #else
36206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36207 #endif
36208 }
36209 return resultobj;
36210 fail:
36211 return NULL;
36212 }
36213
36214
36215 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36216 PyObject *resultobj;
36217 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36218 wxString *result;
36219 PyObject * obj0 = 0 ;
36220 char *kwnames[] = {
36221 (char *) "self", NULL
36222 };
36223
36224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36226 if (SWIG_arg_fail(1)) SWIG_fail;
36227 {
36228 PyThreadState* __tstate = wxPyBeginAllowThreads();
36229 {
36230 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36231 result = (wxString *) &_result_ref;
36232 }
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_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj;
36252 wxString *arg1 = 0 ;
36253 wxString result;
36254 bool temp1 = false ;
36255 PyObject * obj0 = 0 ;
36256 char *kwnames[] = {
36257 (char *) "text", NULL
36258 };
36259
36260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36261 {
36262 arg1 = wxString_in_helper(obj0);
36263 if (arg1 == NULL) SWIG_fail;
36264 temp1 = true;
36265 }
36266 {
36267 PyThreadState* __tstate = wxPyBeginAllowThreads();
36268 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36269
36270 wxPyEndAllowThreads(__tstate);
36271 if (PyErr_Occurred()) SWIG_fail;
36272 }
36273 {
36274 #if wxUSE_UNICODE
36275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36276 #else
36277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36278 #endif
36279 }
36280 {
36281 if (temp1)
36282 delete arg1;
36283 }
36284 return resultobj;
36285 fail:
36286 {
36287 if (temp1)
36288 delete arg1;
36289 }
36290 return NULL;
36291 }
36292
36293
36294 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36295 PyObject *resultobj;
36296 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36297 wxItemKind result;
36298 PyObject * obj0 = 0 ;
36299 char *kwnames[] = {
36300 (char *) "self", NULL
36301 };
36302
36303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36305 if (SWIG_arg_fail(1)) SWIG_fail;
36306 {
36307 PyThreadState* __tstate = wxPyBeginAllowThreads();
36308 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36309
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 resultobj = SWIG_From_int((result));
36314 return resultobj;
36315 fail:
36316 return NULL;
36317 }
36318
36319
36320 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36321 PyObject *resultobj;
36322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36323 wxItemKind arg2 ;
36324 PyObject * obj0 = 0 ;
36325 PyObject * obj1 = 0 ;
36326 char *kwnames[] = {
36327 (char *) "self",(char *) "kind", NULL
36328 };
36329
36330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36332 if (SWIG_arg_fail(1)) SWIG_fail;
36333 {
36334 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36335 if (SWIG_arg_fail(2)) SWIG_fail;
36336 }
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 (arg1)->SetKind((wxItemKind )arg2);
36340
36341 wxPyEndAllowThreads(__tstate);
36342 if (PyErr_Occurred()) SWIG_fail;
36343 }
36344 Py_INCREF(Py_None); resultobj = Py_None;
36345 return resultobj;
36346 fail:
36347 return NULL;
36348 }
36349
36350
36351 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36352 PyObject *resultobj;
36353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36354 bool arg2 ;
36355 PyObject * obj0 = 0 ;
36356 PyObject * obj1 = 0 ;
36357 char *kwnames[] = {
36358 (char *) "self",(char *) "checkable", NULL
36359 };
36360
36361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36363 if (SWIG_arg_fail(1)) SWIG_fail;
36364 {
36365 arg2 = (bool)(SWIG_As_bool(obj1));
36366 if (SWIG_arg_fail(2)) SWIG_fail;
36367 }
36368 {
36369 PyThreadState* __tstate = wxPyBeginAllowThreads();
36370 (arg1)->SetCheckable(arg2);
36371
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 Py_INCREF(Py_None); resultobj = Py_None;
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36383 PyObject *resultobj;
36384 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36385 bool result;
36386 PyObject * obj0 = 0 ;
36387 char *kwnames[] = {
36388 (char *) "self", NULL
36389 };
36390
36391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36393 if (SWIG_arg_fail(1)) SWIG_fail;
36394 {
36395 PyThreadState* __tstate = wxPyBeginAllowThreads();
36396 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36397
36398 wxPyEndAllowThreads(__tstate);
36399 if (PyErr_Occurred()) SWIG_fail;
36400 }
36401 {
36402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36403 }
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36411 PyObject *resultobj;
36412 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36413 bool result;
36414 PyObject * obj0 = 0 ;
36415 char *kwnames[] = {
36416 (char *) "self", NULL
36417 };
36418
36419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36421 if (SWIG_arg_fail(1)) SWIG_fail;
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36425
36426 wxPyEndAllowThreads(__tstate);
36427 if (PyErr_Occurred()) SWIG_fail;
36428 }
36429 {
36430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36431 }
36432 return resultobj;
36433 fail:
36434 return NULL;
36435 }
36436
36437
36438 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36439 PyObject *resultobj;
36440 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36441 wxMenu *arg2 = (wxMenu *) 0 ;
36442 PyObject * obj0 = 0 ;
36443 PyObject * obj1 = 0 ;
36444 char *kwnames[] = {
36445 (char *) "self",(char *) "menu", NULL
36446 };
36447
36448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36450 if (SWIG_arg_fail(1)) SWIG_fail;
36451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36452 if (SWIG_arg_fail(2)) SWIG_fail;
36453 {
36454 PyThreadState* __tstate = wxPyBeginAllowThreads();
36455 (arg1)->SetSubMenu(arg2);
36456
36457 wxPyEndAllowThreads(__tstate);
36458 if (PyErr_Occurred()) SWIG_fail;
36459 }
36460 Py_INCREF(Py_None); resultobj = Py_None;
36461 return resultobj;
36462 fail:
36463 return NULL;
36464 }
36465
36466
36467 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36468 PyObject *resultobj;
36469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36470 wxMenu *result;
36471 PyObject * obj0 = 0 ;
36472 char *kwnames[] = {
36473 (char *) "self", NULL
36474 };
36475
36476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36478 if (SWIG_arg_fail(1)) SWIG_fail;
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36482
36483 wxPyEndAllowThreads(__tstate);
36484 if (PyErr_Occurred()) SWIG_fail;
36485 }
36486 {
36487 resultobj = wxPyMake_wxObject(result, 0);
36488 }
36489 return resultobj;
36490 fail:
36491 return NULL;
36492 }
36493
36494
36495 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36496 PyObject *resultobj;
36497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36498 bool arg2 = (bool) true ;
36499 PyObject * obj0 = 0 ;
36500 PyObject * obj1 = 0 ;
36501 char *kwnames[] = {
36502 (char *) "self",(char *) "enable", NULL
36503 };
36504
36505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36507 if (SWIG_arg_fail(1)) SWIG_fail;
36508 if (obj1) {
36509 {
36510 arg2 = (bool)(SWIG_As_bool(obj1));
36511 if (SWIG_arg_fail(2)) SWIG_fail;
36512 }
36513 }
36514 {
36515 PyThreadState* __tstate = wxPyBeginAllowThreads();
36516 (arg1)->Enable(arg2);
36517
36518 wxPyEndAllowThreads(__tstate);
36519 if (PyErr_Occurred()) SWIG_fail;
36520 }
36521 Py_INCREF(Py_None); resultobj = Py_None;
36522 return resultobj;
36523 fail:
36524 return NULL;
36525 }
36526
36527
36528 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36529 PyObject *resultobj;
36530 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36531 bool result;
36532 PyObject * obj0 = 0 ;
36533 char *kwnames[] = {
36534 (char *) "self", NULL
36535 };
36536
36537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36539 if (SWIG_arg_fail(1)) SWIG_fail;
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36543
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36557 PyObject *resultobj;
36558 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36559 bool arg2 = (bool) true ;
36560 PyObject * obj0 = 0 ;
36561 PyObject * obj1 = 0 ;
36562 char *kwnames[] = {
36563 (char *) "self",(char *) "check", NULL
36564 };
36565
36566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36568 if (SWIG_arg_fail(1)) SWIG_fail;
36569 if (obj1) {
36570 {
36571 arg2 = (bool)(SWIG_As_bool(obj1));
36572 if (SWIG_arg_fail(2)) SWIG_fail;
36573 }
36574 }
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 (arg1)->Check(arg2);
36578
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 Py_INCREF(Py_None); resultobj = Py_None;
36583 return resultobj;
36584 fail:
36585 return NULL;
36586 }
36587
36588
36589 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36590 PyObject *resultobj;
36591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36592 bool result;
36593 PyObject * obj0 = 0 ;
36594 char *kwnames[] = {
36595 (char *) "self", NULL
36596 };
36597
36598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36600 if (SWIG_arg_fail(1)) SWIG_fail;
36601 {
36602 PyThreadState* __tstate = wxPyBeginAllowThreads();
36603 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36604
36605 wxPyEndAllowThreads(__tstate);
36606 if (PyErr_Occurred()) SWIG_fail;
36607 }
36608 {
36609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36610 }
36611 return resultobj;
36612 fail:
36613 return NULL;
36614 }
36615
36616
36617 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36618 PyObject *resultobj;
36619 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36620 PyObject * obj0 = 0 ;
36621 char *kwnames[] = {
36622 (char *) "self", NULL
36623 };
36624
36625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36627 if (SWIG_arg_fail(1)) SWIG_fail;
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 (arg1)->Toggle();
36631
36632 wxPyEndAllowThreads(__tstate);
36633 if (PyErr_Occurred()) SWIG_fail;
36634 }
36635 Py_INCREF(Py_None); resultobj = Py_None;
36636 return resultobj;
36637 fail:
36638 return NULL;
36639 }
36640
36641
36642 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36643 PyObject *resultobj;
36644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36645 wxString *arg2 = 0 ;
36646 bool temp2 = false ;
36647 PyObject * obj0 = 0 ;
36648 PyObject * obj1 = 0 ;
36649 char *kwnames[] = {
36650 (char *) "self",(char *) "str", NULL
36651 };
36652
36653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36655 if (SWIG_arg_fail(1)) SWIG_fail;
36656 {
36657 arg2 = wxString_in_helper(obj1);
36658 if (arg2 == NULL) SWIG_fail;
36659 temp2 = true;
36660 }
36661 {
36662 PyThreadState* __tstate = wxPyBeginAllowThreads();
36663 (arg1)->SetHelp((wxString const &)*arg2);
36664
36665 wxPyEndAllowThreads(__tstate);
36666 if (PyErr_Occurred()) SWIG_fail;
36667 }
36668 Py_INCREF(Py_None); resultobj = Py_None;
36669 {
36670 if (temp2)
36671 delete arg2;
36672 }
36673 return resultobj;
36674 fail:
36675 {
36676 if (temp2)
36677 delete arg2;
36678 }
36679 return NULL;
36680 }
36681
36682
36683 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36684 PyObject *resultobj;
36685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36686 wxString *result;
36687 PyObject * obj0 = 0 ;
36688 char *kwnames[] = {
36689 (char *) "self", NULL
36690 };
36691
36692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36694 if (SWIG_arg_fail(1)) SWIG_fail;
36695 {
36696 PyThreadState* __tstate = wxPyBeginAllowThreads();
36697 {
36698 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36699 result = (wxString *) &_result_ref;
36700 }
36701
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 {
36706 #if wxUSE_UNICODE
36707 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36708 #else
36709 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36710 #endif
36711 }
36712 return resultobj;
36713 fail:
36714 return NULL;
36715 }
36716
36717
36718 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36719 PyObject *resultobj;
36720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36721 wxAcceleratorEntry *result;
36722 PyObject * obj0 = 0 ;
36723 char *kwnames[] = {
36724 (char *) "self", NULL
36725 };
36726
36727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",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 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36733
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36745 PyObject *resultobj;
36746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36747 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36748 PyObject * obj0 = 0 ;
36749 PyObject * obj1 = 0 ;
36750 char *kwnames[] = {
36751 (char *) "self",(char *) "accel", NULL
36752 };
36753
36754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36756 if (SWIG_arg_fail(1)) SWIG_fail;
36757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36758 if (SWIG_arg_fail(2)) SWIG_fail;
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 (arg1)->SetAccel(arg2);
36762
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 Py_INCREF(Py_None); resultobj = Py_None;
36767 return resultobj;
36768 fail:
36769 return NULL;
36770 }
36771
36772
36773 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36774 PyObject *resultobj;
36775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36776 wxFont *arg2 = 0 ;
36777 PyObject * obj0 = 0 ;
36778 PyObject * obj1 = 0 ;
36779 char *kwnames[] = {
36780 (char *) "self",(char *) "font", NULL
36781 };
36782
36783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36785 if (SWIG_arg_fail(1)) SWIG_fail;
36786 {
36787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36788 if (SWIG_arg_fail(2)) SWIG_fail;
36789 if (arg2 == NULL) {
36790 SWIG_null_ref("wxFont");
36791 }
36792 if (SWIG_arg_fail(2)) SWIG_fail;
36793 }
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 wxMenuItem_SetFont(arg1,(wxFont const &)*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_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36809 PyObject *resultobj;
36810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36811 wxFont result;
36812 PyObject * obj0 = 0 ;
36813 char *kwnames[] = {
36814 (char *) "self", NULL
36815 };
36816
36817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36819 if (SWIG_arg_fail(1)) SWIG_fail;
36820 {
36821 PyThreadState* __tstate = wxPyBeginAllowThreads();
36822 result = wxMenuItem_GetFont(arg1);
36823
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 {
36828 wxFont * resultptr;
36829 resultptr = new wxFont((wxFont &)(result));
36830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36831 }
36832 return resultobj;
36833 fail:
36834 return NULL;
36835 }
36836
36837
36838 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36839 PyObject *resultobj;
36840 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36841 wxColour *arg2 = 0 ;
36842 wxColour temp2 ;
36843 PyObject * obj0 = 0 ;
36844 PyObject * obj1 = 0 ;
36845 char *kwnames[] = {
36846 (char *) "self",(char *) "colText", NULL
36847 };
36848
36849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36851 if (SWIG_arg_fail(1)) SWIG_fail;
36852 {
36853 arg2 = &temp2;
36854 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36855 }
36856 {
36857 PyThreadState* __tstate = wxPyBeginAllowThreads();
36858 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36859
36860 wxPyEndAllowThreads(__tstate);
36861 if (PyErr_Occurred()) SWIG_fail;
36862 }
36863 Py_INCREF(Py_None); resultobj = Py_None;
36864 return resultobj;
36865 fail:
36866 return NULL;
36867 }
36868
36869
36870 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36871 PyObject *resultobj;
36872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36873 wxColour result;
36874 PyObject * obj0 = 0 ;
36875 char *kwnames[] = {
36876 (char *) "self", NULL
36877 };
36878
36879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36881 if (SWIG_arg_fail(1)) SWIG_fail;
36882 {
36883 PyThreadState* __tstate = wxPyBeginAllowThreads();
36884 result = wxMenuItem_GetTextColour(arg1);
36885
36886 wxPyEndAllowThreads(__tstate);
36887 if (PyErr_Occurred()) SWIG_fail;
36888 }
36889 {
36890 wxColour * resultptr;
36891 resultptr = new wxColour((wxColour &)(result));
36892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36893 }
36894 return resultobj;
36895 fail:
36896 return NULL;
36897 }
36898
36899
36900 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36901 PyObject *resultobj;
36902 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36903 wxColour *arg2 = 0 ;
36904 wxColour temp2 ;
36905 PyObject * obj0 = 0 ;
36906 PyObject * obj1 = 0 ;
36907 char *kwnames[] = {
36908 (char *) "self",(char *) "colBack", NULL
36909 };
36910
36911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36913 if (SWIG_arg_fail(1)) SWIG_fail;
36914 {
36915 arg2 = &temp2;
36916 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36917 }
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36921
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 Py_INCREF(Py_None); resultobj = Py_None;
36926 return resultobj;
36927 fail:
36928 return NULL;
36929 }
36930
36931
36932 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36933 PyObject *resultobj;
36934 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36935 wxColour result;
36936 PyObject * obj0 = 0 ;
36937 char *kwnames[] = {
36938 (char *) "self", NULL
36939 };
36940
36941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36943 if (SWIG_arg_fail(1)) SWIG_fail;
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 result = wxMenuItem_GetBackgroundColour(arg1);
36947
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 {
36952 wxColour * resultptr;
36953 resultptr = new wxColour((wxColour &)(result));
36954 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36955 }
36956 return resultobj;
36957 fail:
36958 return NULL;
36959 }
36960
36961
36962 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36963 PyObject *resultobj;
36964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36965 wxBitmap *arg2 = 0 ;
36966 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36967 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36968 PyObject * obj0 = 0 ;
36969 PyObject * obj1 = 0 ;
36970 PyObject * obj2 = 0 ;
36971 char *kwnames[] = {
36972 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36973 };
36974
36975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36977 if (SWIG_arg_fail(1)) SWIG_fail;
36978 {
36979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36980 if (SWIG_arg_fail(2)) SWIG_fail;
36981 if (arg2 == NULL) {
36982 SWIG_null_ref("wxBitmap");
36983 }
36984 if (SWIG_arg_fail(2)) SWIG_fail;
36985 }
36986 if (obj2) {
36987 {
36988 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36989 if (SWIG_arg_fail(3)) SWIG_fail;
36990 if (arg3 == NULL) {
36991 SWIG_null_ref("wxBitmap");
36992 }
36993 if (SWIG_arg_fail(3)) SWIG_fail;
36994 }
36995 }
36996 {
36997 PyThreadState* __tstate = wxPyBeginAllowThreads();
36998 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36999
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 Py_INCREF(Py_None); resultobj = Py_None;
37004 return resultobj;
37005 fail:
37006 return NULL;
37007 }
37008
37009
37010 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37011 PyObject *resultobj;
37012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37013 wxBitmap *arg2 = 0 ;
37014 PyObject * obj0 = 0 ;
37015 PyObject * obj1 = 0 ;
37016 char *kwnames[] = {
37017 (char *) "self",(char *) "bmpDisabled", NULL
37018 };
37019
37020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37022 if (SWIG_arg_fail(1)) SWIG_fail;
37023 {
37024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37025 if (SWIG_arg_fail(2)) SWIG_fail;
37026 if (arg2 == NULL) {
37027 SWIG_null_ref("wxBitmap");
37028 }
37029 if (SWIG_arg_fail(2)) SWIG_fail;
37030 }
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
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_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj;
37047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37048 wxBitmap *result;
37049 PyObject * obj0 = 0 ;
37050 char *kwnames[] = {
37051 (char *) "self", NULL
37052 };
37053
37054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37056 if (SWIG_arg_fail(1)) SWIG_fail;
37057 {
37058 PyThreadState* __tstate = wxPyBeginAllowThreads();
37059 {
37060 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37061 result = (wxBitmap *) &_result_ref;
37062 }
37063
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 {
37068 wxBitmap* resultptr = new wxBitmap(*result);
37069 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37070 }
37071 return resultobj;
37072 fail:
37073 return NULL;
37074 }
37075
37076
37077 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37078 PyObject *resultobj;
37079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37080 int arg2 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char *kwnames[] = {
37084 (char *) "self",(char *) "nWidth", NULL
37085 };
37086
37087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37089 if (SWIG_arg_fail(1)) SWIG_fail;
37090 {
37091 arg2 = (int)(SWIG_As_int(obj1));
37092 if (SWIG_arg_fail(2)) SWIG_fail;
37093 }
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 wxMenuItem_SetMarginWidth(arg1,arg2);
37097
37098 wxPyEndAllowThreads(__tstate);
37099 if (PyErr_Occurred()) SWIG_fail;
37100 }
37101 Py_INCREF(Py_None); resultobj = Py_None;
37102 return resultobj;
37103 fail:
37104 return NULL;
37105 }
37106
37107
37108 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37109 PyObject *resultobj;
37110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37111 int result;
37112 PyObject * obj0 = 0 ;
37113 char *kwnames[] = {
37114 (char *) "self", NULL
37115 };
37116
37117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37119 if (SWIG_arg_fail(1)) SWIG_fail;
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = (int)wxMenuItem_GetMarginWidth(arg1);
37123
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 {
37128 resultobj = SWIG_From_int((int)(result));
37129 }
37130 return resultobj;
37131 fail:
37132 return NULL;
37133 }
37134
37135
37136 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37137 PyObject *resultobj;
37138 int result;
37139 char *kwnames[] = {
37140 NULL
37141 };
37142
37143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37144 {
37145 PyThreadState* __tstate = wxPyBeginAllowThreads();
37146 result = (int)MenuItem_GetDefaultMarginWidth();
37147
37148 wxPyEndAllowThreads(__tstate);
37149 if (PyErr_Occurred()) SWIG_fail;
37150 }
37151 {
37152 resultobj = SWIG_From_int((int)(result));
37153 }
37154 return resultobj;
37155 fail:
37156 return NULL;
37157 }
37158
37159
37160 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37161 PyObject *resultobj;
37162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37163 bool result;
37164 PyObject * obj0 = 0 ;
37165 char *kwnames[] = {
37166 (char *) "self", NULL
37167 };
37168
37169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37171 if (SWIG_arg_fail(1)) SWIG_fail;
37172 {
37173 PyThreadState* __tstate = wxPyBeginAllowThreads();
37174 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37175
37176 wxPyEndAllowThreads(__tstate);
37177 if (PyErr_Occurred()) SWIG_fail;
37178 }
37179 {
37180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37181 }
37182 return resultobj;
37183 fail:
37184 return NULL;
37185 }
37186
37187
37188 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37189 PyObject *resultobj;
37190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37191 bool arg2 = (bool) true ;
37192 PyObject * obj0 = 0 ;
37193 PyObject * obj1 = 0 ;
37194 char *kwnames[] = {
37195 (char *) "self",(char *) "ownerDrawn", NULL
37196 };
37197
37198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37200 if (SWIG_arg_fail(1)) SWIG_fail;
37201 if (obj1) {
37202 {
37203 arg2 = (bool)(SWIG_As_bool(obj1));
37204 if (SWIG_arg_fail(2)) SWIG_fail;
37205 }
37206 }
37207 {
37208 PyThreadState* __tstate = wxPyBeginAllowThreads();
37209 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37210
37211 wxPyEndAllowThreads(__tstate);
37212 if (PyErr_Occurred()) SWIG_fail;
37213 }
37214 Py_INCREF(Py_None); resultobj = Py_None;
37215 return resultobj;
37216 fail:
37217 return NULL;
37218 }
37219
37220
37221 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37222 PyObject *resultobj;
37223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37224 PyObject * obj0 = 0 ;
37225 char *kwnames[] = {
37226 (char *) "self", NULL
37227 };
37228
37229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37231 if (SWIG_arg_fail(1)) SWIG_fail;
37232 {
37233 PyThreadState* __tstate = wxPyBeginAllowThreads();
37234 wxMenuItem_ResetOwnerDrawn(arg1);
37235
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 Py_INCREF(Py_None); resultobj = Py_None;
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj;
37248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37249 wxBitmap *arg2 = 0 ;
37250 PyObject * obj0 = 0 ;
37251 PyObject * obj1 = 0 ;
37252 char *kwnames[] = {
37253 (char *) "self",(char *) "bitmap", NULL
37254 };
37255
37256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37258 if (SWIG_arg_fail(1)) SWIG_fail;
37259 {
37260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37261 if (SWIG_arg_fail(2)) SWIG_fail;
37262 if (arg2 == NULL) {
37263 SWIG_null_ref("wxBitmap");
37264 }
37265 if (SWIG_arg_fail(2)) SWIG_fail;
37266 }
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 (arg1)->SetBitmap((wxBitmap const &)*arg2);
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_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj;
37283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37284 wxBitmap *result;
37285 PyObject * obj0 = 0 ;
37286 char *kwnames[] = {
37287 (char *) "self", NULL
37288 };
37289
37290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37292 if (SWIG_arg_fail(1)) SWIG_fail;
37293 {
37294 PyThreadState* __tstate = wxPyBeginAllowThreads();
37295 {
37296 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37297 result = (wxBitmap *) &_result_ref;
37298 }
37299
37300 wxPyEndAllowThreads(__tstate);
37301 if (PyErr_Occurred()) SWIG_fail;
37302 }
37303 {
37304 wxBitmap* resultptr = new wxBitmap(*result);
37305 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37306 }
37307 return resultobj;
37308 fail:
37309 return NULL;
37310 }
37311
37312
37313 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37314 PyObject *obj;
37315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37316 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37317 Py_INCREF(obj);
37318 return Py_BuildValue((char *)"");
37319 }
37320 static int _wrap_ControlNameStr_set(PyObject *) {
37321 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37322 return 1;
37323 }
37324
37325
37326 static PyObject *_wrap_ControlNameStr_get(void) {
37327 PyObject *pyobj;
37328
37329 {
37330 #if wxUSE_UNICODE
37331 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37332 #else
37333 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37334 #endif
37335 }
37336 return pyobj;
37337 }
37338
37339
37340 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37341 PyObject *resultobj;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 int arg2 = (int) -1 ;
37344 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37345 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37346 wxSize const &arg4_defvalue = wxDefaultSize ;
37347 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37348 long arg5 = (long) 0 ;
37349 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37350 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37351 wxString const &arg7_defvalue = wxPyControlNameStr ;
37352 wxString *arg7 = (wxString *) &arg7_defvalue ;
37353 wxControl *result;
37354 wxPoint temp3 ;
37355 wxSize temp4 ;
37356 bool temp7 = false ;
37357 PyObject * obj0 = 0 ;
37358 PyObject * obj1 = 0 ;
37359 PyObject * obj2 = 0 ;
37360 PyObject * obj3 = 0 ;
37361 PyObject * obj4 = 0 ;
37362 PyObject * obj5 = 0 ;
37363 PyObject * obj6 = 0 ;
37364 char *kwnames[] = {
37365 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37366 };
37367
37368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37370 if (SWIG_arg_fail(1)) SWIG_fail;
37371 if (obj1) {
37372 {
37373 arg2 = (int)(SWIG_As_int(obj1));
37374 if (SWIG_arg_fail(2)) SWIG_fail;
37375 }
37376 }
37377 if (obj2) {
37378 {
37379 arg3 = &temp3;
37380 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37381 }
37382 }
37383 if (obj3) {
37384 {
37385 arg4 = &temp4;
37386 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37387 }
37388 }
37389 if (obj4) {
37390 {
37391 arg5 = (long)(SWIG_As_long(obj4));
37392 if (SWIG_arg_fail(5)) SWIG_fail;
37393 }
37394 }
37395 if (obj5) {
37396 {
37397 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37398 if (SWIG_arg_fail(6)) SWIG_fail;
37399 if (arg6 == NULL) {
37400 SWIG_null_ref("wxValidator");
37401 }
37402 if (SWIG_arg_fail(6)) SWIG_fail;
37403 }
37404 }
37405 if (obj6) {
37406 {
37407 arg7 = wxString_in_helper(obj6);
37408 if (arg7 == NULL) SWIG_fail;
37409 temp7 = true;
37410 }
37411 }
37412 {
37413 if (!wxPyCheckForApp()) SWIG_fail;
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37416
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37421 {
37422 if (temp7)
37423 delete arg7;
37424 }
37425 return resultobj;
37426 fail:
37427 {
37428 if (temp7)
37429 delete arg7;
37430 }
37431 return NULL;
37432 }
37433
37434
37435 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37436 PyObject *resultobj;
37437 wxControl *result;
37438 char *kwnames[] = {
37439 NULL
37440 };
37441
37442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37443 {
37444 if (!wxPyCheckForApp()) SWIG_fail;
37445 PyThreadState* __tstate = wxPyBeginAllowThreads();
37446 result = (wxControl *)new wxControl();
37447
37448 wxPyEndAllowThreads(__tstate);
37449 if (PyErr_Occurred()) SWIG_fail;
37450 }
37451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37459 PyObject *resultobj;
37460 wxControl *arg1 = (wxControl *) 0 ;
37461 wxWindow *arg2 = (wxWindow *) 0 ;
37462 int arg3 = (int) -1 ;
37463 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37464 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37465 wxSize const &arg5_defvalue = wxDefaultSize ;
37466 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37467 long arg6 = (long) 0 ;
37468 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37469 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37470 wxString const &arg8_defvalue = wxPyControlNameStr ;
37471 wxString *arg8 = (wxString *) &arg8_defvalue ;
37472 bool result;
37473 wxPoint temp4 ;
37474 wxSize temp5 ;
37475 bool temp8 = false ;
37476 PyObject * obj0 = 0 ;
37477 PyObject * obj1 = 0 ;
37478 PyObject * obj2 = 0 ;
37479 PyObject * obj3 = 0 ;
37480 PyObject * obj4 = 0 ;
37481 PyObject * obj5 = 0 ;
37482 PyObject * obj6 = 0 ;
37483 PyObject * obj7 = 0 ;
37484 char *kwnames[] = {
37485 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37486 };
37487
37488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37490 if (SWIG_arg_fail(1)) SWIG_fail;
37491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37492 if (SWIG_arg_fail(2)) SWIG_fail;
37493 if (obj2) {
37494 {
37495 arg3 = (int)(SWIG_As_int(obj2));
37496 if (SWIG_arg_fail(3)) SWIG_fail;
37497 }
37498 }
37499 if (obj3) {
37500 {
37501 arg4 = &temp4;
37502 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37503 }
37504 }
37505 if (obj4) {
37506 {
37507 arg5 = &temp5;
37508 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37509 }
37510 }
37511 if (obj5) {
37512 {
37513 arg6 = (long)(SWIG_As_long(obj5));
37514 if (SWIG_arg_fail(6)) SWIG_fail;
37515 }
37516 }
37517 if (obj6) {
37518 {
37519 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37520 if (SWIG_arg_fail(7)) SWIG_fail;
37521 if (arg7 == NULL) {
37522 SWIG_null_ref("wxValidator");
37523 }
37524 if (SWIG_arg_fail(7)) SWIG_fail;
37525 }
37526 }
37527 if (obj7) {
37528 {
37529 arg8 = wxString_in_helper(obj7);
37530 if (arg8 == NULL) SWIG_fail;
37531 temp8 = true;
37532 }
37533 }
37534 {
37535 PyThreadState* __tstate = wxPyBeginAllowThreads();
37536 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37537
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 {
37542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37543 }
37544 {
37545 if (temp8)
37546 delete arg8;
37547 }
37548 return resultobj;
37549 fail:
37550 {
37551 if (temp8)
37552 delete arg8;
37553 }
37554 return NULL;
37555 }
37556
37557
37558 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37559 PyObject *resultobj;
37560 wxControl *arg1 = (wxControl *) 0 ;
37561 wxCommandEvent *arg2 = 0 ;
37562 PyObject * obj0 = 0 ;
37563 PyObject * obj1 = 0 ;
37564 char *kwnames[] = {
37565 (char *) "self",(char *) "event", NULL
37566 };
37567
37568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37570 if (SWIG_arg_fail(1)) SWIG_fail;
37571 {
37572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37573 if (SWIG_arg_fail(2)) SWIG_fail;
37574 if (arg2 == NULL) {
37575 SWIG_null_ref("wxCommandEvent");
37576 }
37577 if (SWIG_arg_fail(2)) SWIG_fail;
37578 }
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 (arg1)->Command(*arg2);
37582
37583 wxPyEndAllowThreads(__tstate);
37584 if (PyErr_Occurred()) SWIG_fail;
37585 }
37586 Py_INCREF(Py_None); resultobj = Py_None;
37587 return resultobj;
37588 fail:
37589 return NULL;
37590 }
37591
37592
37593 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37594 PyObject *resultobj;
37595 wxControl *arg1 = (wxControl *) 0 ;
37596 wxString result;
37597 PyObject * obj0 = 0 ;
37598 char *kwnames[] = {
37599 (char *) "self", NULL
37600 };
37601
37602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37604 if (SWIG_arg_fail(1)) SWIG_fail;
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 result = (arg1)->GetLabel();
37608
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 {
37613 #if wxUSE_UNICODE
37614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37615 #else
37616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37617 #endif
37618 }
37619 return resultobj;
37620 fail:
37621 return NULL;
37622 }
37623
37624
37625 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37626 PyObject *resultobj;
37627 wxControl *arg1 = (wxControl *) 0 ;
37628 wxString *arg2 = 0 ;
37629 bool temp2 = false ;
37630 PyObject * obj0 = 0 ;
37631 PyObject * obj1 = 0 ;
37632 char *kwnames[] = {
37633 (char *) "self",(char *) "label", NULL
37634 };
37635
37636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37638 if (SWIG_arg_fail(1)) SWIG_fail;
37639 {
37640 arg2 = wxString_in_helper(obj1);
37641 if (arg2 == NULL) SWIG_fail;
37642 temp2 = true;
37643 }
37644 {
37645 PyThreadState* __tstate = wxPyBeginAllowThreads();
37646 (arg1)->SetLabel((wxString const &)*arg2);
37647
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 Py_INCREF(Py_None); resultobj = Py_None;
37652 {
37653 if (temp2)
37654 delete arg2;
37655 }
37656 return resultobj;
37657 fail:
37658 {
37659 if (temp2)
37660 delete arg2;
37661 }
37662 return NULL;
37663 }
37664
37665
37666 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37667 PyObject *resultobj;
37668 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37669 wxVisualAttributes result;
37670 PyObject * obj0 = 0 ;
37671 char *kwnames[] = {
37672 (char *) "variant", NULL
37673 };
37674
37675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37676 if (obj0) {
37677 {
37678 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37679 if (SWIG_arg_fail(1)) SWIG_fail;
37680 }
37681 }
37682 {
37683 if (!wxPyCheckForApp()) SWIG_fail;
37684 PyThreadState* __tstate = wxPyBeginAllowThreads();
37685 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37686
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 {
37691 wxVisualAttributes * resultptr;
37692 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37694 }
37695 return resultobj;
37696 fail:
37697 return NULL;
37698 }
37699
37700
37701 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37702 PyObject *obj;
37703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37704 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37705 Py_INCREF(obj);
37706 return Py_BuildValue((char *)"");
37707 }
37708 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37709 PyObject *resultobj;
37710 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37711 wxString *arg2 = 0 ;
37712 PyObject *arg3 = (PyObject *) NULL ;
37713 int result;
37714 bool temp2 = false ;
37715 PyObject * obj0 = 0 ;
37716 PyObject * obj1 = 0 ;
37717 PyObject * obj2 = 0 ;
37718 char *kwnames[] = {
37719 (char *) "self",(char *) "item",(char *) "clientData", NULL
37720 };
37721
37722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37724 if (SWIG_arg_fail(1)) SWIG_fail;
37725 {
37726 arg2 = wxString_in_helper(obj1);
37727 if (arg2 == NULL) SWIG_fail;
37728 temp2 = true;
37729 }
37730 if (obj2) {
37731 arg3 = obj2;
37732 }
37733 {
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37736
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 {
37741 resultobj = SWIG_From_int((int)(result));
37742 }
37743 {
37744 if (temp2)
37745 delete arg2;
37746 }
37747 return resultobj;
37748 fail:
37749 {
37750 if (temp2)
37751 delete arg2;
37752 }
37753 return NULL;
37754 }
37755
37756
37757 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37758 PyObject *resultobj;
37759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37760 wxArrayString *arg2 = 0 ;
37761 bool temp2 = false ;
37762 PyObject * obj0 = 0 ;
37763 PyObject * obj1 = 0 ;
37764 char *kwnames[] = {
37765 (char *) "self",(char *) "strings", NULL
37766 };
37767
37768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37770 if (SWIG_arg_fail(1)) SWIG_fail;
37771 {
37772 if (! PySequence_Check(obj1)) {
37773 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37774 SWIG_fail;
37775 }
37776 arg2 = new wxArrayString;
37777 temp2 = true;
37778 int i, len=PySequence_Length(obj1);
37779 for (i=0; i<len; i++) {
37780 PyObject* item = PySequence_GetItem(obj1, i);
37781 #if wxUSE_UNICODE
37782 PyObject* str = PyObject_Unicode(item);
37783 #else
37784 PyObject* str = PyObject_Str(item);
37785 #endif
37786 if (PyErr_Occurred()) SWIG_fail;
37787 arg2->Add(Py2wxString(str));
37788 Py_DECREF(item);
37789 Py_DECREF(str);
37790 }
37791 }
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 (arg1)->Append((wxArrayString const &)*arg2);
37795
37796 wxPyEndAllowThreads(__tstate);
37797 if (PyErr_Occurred()) SWIG_fail;
37798 }
37799 Py_INCREF(Py_None); resultobj = Py_None;
37800 {
37801 if (temp2) delete arg2;
37802 }
37803 return resultobj;
37804 fail:
37805 {
37806 if (temp2) delete arg2;
37807 }
37808 return NULL;
37809 }
37810
37811
37812 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37813 PyObject *resultobj;
37814 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37815 wxString *arg2 = 0 ;
37816 int arg3 ;
37817 PyObject *arg4 = (PyObject *) NULL ;
37818 int result;
37819 bool temp2 = false ;
37820 PyObject * obj0 = 0 ;
37821 PyObject * obj1 = 0 ;
37822 PyObject * obj2 = 0 ;
37823 PyObject * obj3 = 0 ;
37824 char *kwnames[] = {
37825 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37826 };
37827
37828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37830 if (SWIG_arg_fail(1)) SWIG_fail;
37831 {
37832 arg2 = wxString_in_helper(obj1);
37833 if (arg2 == NULL) SWIG_fail;
37834 temp2 = true;
37835 }
37836 {
37837 arg3 = (int)(SWIG_As_int(obj2));
37838 if (SWIG_arg_fail(3)) SWIG_fail;
37839 }
37840 if (obj3) {
37841 arg4 = obj3;
37842 }
37843 {
37844 PyThreadState* __tstate = wxPyBeginAllowThreads();
37845 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37846
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 {
37851 resultobj = SWIG_From_int((int)(result));
37852 }
37853 {
37854 if (temp2)
37855 delete arg2;
37856 }
37857 return resultobj;
37858 fail:
37859 {
37860 if (temp2)
37861 delete arg2;
37862 }
37863 return NULL;
37864 }
37865
37866
37867 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37868 PyObject *resultobj;
37869 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37870 PyObject * obj0 = 0 ;
37871 char *kwnames[] = {
37872 (char *) "self", NULL
37873 };
37874
37875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37877 if (SWIG_arg_fail(1)) SWIG_fail;
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 (arg1)->Clear();
37881
37882 wxPyEndAllowThreads(__tstate);
37883 if (PyErr_Occurred()) SWIG_fail;
37884 }
37885 Py_INCREF(Py_None); resultobj = Py_None;
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37893 PyObject *resultobj;
37894 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37895 int arg2 ;
37896 PyObject * obj0 = 0 ;
37897 PyObject * obj1 = 0 ;
37898 char *kwnames[] = {
37899 (char *) "self",(char *) "n", NULL
37900 };
37901
37902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37904 if (SWIG_arg_fail(1)) SWIG_fail;
37905 {
37906 arg2 = (int)(SWIG_As_int(obj1));
37907 if (SWIG_arg_fail(2)) SWIG_fail;
37908 }
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 (arg1)->Delete(arg2);
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_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37924 PyObject *resultobj;
37925 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37926 int arg2 ;
37927 PyObject *result;
37928 PyObject * obj0 = 0 ;
37929 PyObject * obj1 = 0 ;
37930 char *kwnames[] = {
37931 (char *) "self",(char *) "n", NULL
37932 };
37933
37934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37936 if (SWIG_arg_fail(1)) SWIG_fail;
37937 {
37938 arg2 = (int)(SWIG_As_int(obj1));
37939 if (SWIG_arg_fail(2)) SWIG_fail;
37940 }
37941 {
37942 PyThreadState* __tstate = wxPyBeginAllowThreads();
37943 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37944
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 resultobj = result;
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37956 PyObject *resultobj;
37957 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37958 int arg2 ;
37959 PyObject *arg3 = (PyObject *) 0 ;
37960 PyObject * obj0 = 0 ;
37961 PyObject * obj1 = 0 ;
37962 PyObject * obj2 = 0 ;
37963 char *kwnames[] = {
37964 (char *) "self",(char *) "n",(char *) "clientData", NULL
37965 };
37966
37967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37969 if (SWIG_arg_fail(1)) SWIG_fail;
37970 {
37971 arg2 = (int)(SWIG_As_int(obj1));
37972 if (SWIG_arg_fail(2)) SWIG_fail;
37973 }
37974 arg3 = obj2;
37975 {
37976 PyThreadState* __tstate = wxPyBeginAllowThreads();
37977 wxItemContainer_SetClientData(arg1,arg2,arg3);
37978
37979 wxPyEndAllowThreads(__tstate);
37980 if (PyErr_Occurred()) SWIG_fail;
37981 }
37982 Py_INCREF(Py_None); resultobj = Py_None;
37983 return resultobj;
37984 fail:
37985 return NULL;
37986 }
37987
37988
37989 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37990 PyObject *resultobj;
37991 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37992 int result;
37993 PyObject * obj0 = 0 ;
37994 char *kwnames[] = {
37995 (char *) "self", NULL
37996 };
37997
37998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (int)((wxItemContainer const *)arg1)->GetCount();
38004
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 {
38009 resultobj = SWIG_From_int((int)(result));
38010 }
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38018 PyObject *resultobj;
38019 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38020 bool result;
38021 PyObject * obj0 = 0 ;
38022 char *kwnames[] = {
38023 (char *) "self", NULL
38024 };
38025
38026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38028 if (SWIG_arg_fail(1)) SWIG_fail;
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38032
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 {
38037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj;
38047 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38048 int arg2 ;
38049 wxString result;
38050 PyObject * obj0 = 0 ;
38051 PyObject * obj1 = 0 ;
38052 char *kwnames[] = {
38053 (char *) "self",(char *) "n", NULL
38054 };
38055
38056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38058 if (SWIG_arg_fail(1)) SWIG_fail;
38059 {
38060 arg2 = (int)(SWIG_As_int(obj1));
38061 if (SWIG_arg_fail(2)) SWIG_fail;
38062 }
38063 {
38064 PyThreadState* __tstate = wxPyBeginAllowThreads();
38065 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38066
38067 wxPyEndAllowThreads(__tstate);
38068 if (PyErr_Occurred()) SWIG_fail;
38069 }
38070 {
38071 #if wxUSE_UNICODE
38072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38073 #else
38074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38075 #endif
38076 }
38077 return resultobj;
38078 fail:
38079 return NULL;
38080 }
38081
38082
38083 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38084 PyObject *resultobj;
38085 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38086 wxArrayString result;
38087 PyObject * obj0 = 0 ;
38088 char *kwnames[] = {
38089 (char *) "self", NULL
38090 };
38091
38092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38094 if (SWIG_arg_fail(1)) SWIG_fail;
38095 {
38096 PyThreadState* __tstate = wxPyBeginAllowThreads();
38097 result = ((wxItemContainer const *)arg1)->GetStrings();
38098
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 {
38103 resultobj = wxArrayString2PyList_helper(result);
38104 }
38105 return resultobj;
38106 fail:
38107 return NULL;
38108 }
38109
38110
38111 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38112 PyObject *resultobj;
38113 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38114 int arg2 ;
38115 wxString *arg3 = 0 ;
38116 bool temp3 = false ;
38117 PyObject * obj0 = 0 ;
38118 PyObject * obj1 = 0 ;
38119 PyObject * obj2 = 0 ;
38120 char *kwnames[] = {
38121 (char *) "self",(char *) "n",(char *) "s", NULL
38122 };
38123
38124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38126 if (SWIG_arg_fail(1)) SWIG_fail;
38127 {
38128 arg2 = (int)(SWIG_As_int(obj1));
38129 if (SWIG_arg_fail(2)) SWIG_fail;
38130 }
38131 {
38132 arg3 = wxString_in_helper(obj2);
38133 if (arg3 == NULL) SWIG_fail;
38134 temp3 = true;
38135 }
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 (arg1)->SetString(arg2,(wxString const &)*arg3);
38139
38140 wxPyEndAllowThreads(__tstate);
38141 if (PyErr_Occurred()) SWIG_fail;
38142 }
38143 Py_INCREF(Py_None); resultobj = Py_None;
38144 {
38145 if (temp3)
38146 delete arg3;
38147 }
38148 return resultobj;
38149 fail:
38150 {
38151 if (temp3)
38152 delete arg3;
38153 }
38154 return NULL;
38155 }
38156
38157
38158 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38159 PyObject *resultobj;
38160 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38161 wxString *arg2 = 0 ;
38162 int result;
38163 bool temp2 = false ;
38164 PyObject * obj0 = 0 ;
38165 PyObject * obj1 = 0 ;
38166 char *kwnames[] = {
38167 (char *) "self",(char *) "s", NULL
38168 };
38169
38170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38172 if (SWIG_arg_fail(1)) SWIG_fail;
38173 {
38174 arg2 = wxString_in_helper(obj1);
38175 if (arg2 == NULL) SWIG_fail;
38176 temp2 = true;
38177 }
38178 {
38179 PyThreadState* __tstate = wxPyBeginAllowThreads();
38180 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38181
38182 wxPyEndAllowThreads(__tstate);
38183 if (PyErr_Occurred()) SWIG_fail;
38184 }
38185 {
38186 resultobj = SWIG_From_int((int)(result));
38187 }
38188 {
38189 if (temp2)
38190 delete arg2;
38191 }
38192 return resultobj;
38193 fail:
38194 {
38195 if (temp2)
38196 delete arg2;
38197 }
38198 return NULL;
38199 }
38200
38201
38202 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38203 PyObject *resultobj;
38204 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38205 int arg2 ;
38206 PyObject * obj0 = 0 ;
38207 PyObject * obj1 = 0 ;
38208 char *kwnames[] = {
38209 (char *) "self",(char *) "n", NULL
38210 };
38211
38212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38214 if (SWIG_arg_fail(1)) SWIG_fail;
38215 {
38216 arg2 = (int)(SWIG_As_int(obj1));
38217 if (SWIG_arg_fail(2)) SWIG_fail;
38218 }
38219 {
38220 PyThreadState* __tstate = wxPyBeginAllowThreads();
38221 (arg1)->SetSelection(arg2);
38222
38223 wxPyEndAllowThreads(__tstate);
38224 if (PyErr_Occurred()) SWIG_fail;
38225 }
38226 Py_INCREF(Py_None); resultobj = Py_None;
38227 return resultobj;
38228 fail:
38229 return NULL;
38230 }
38231
38232
38233 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj;
38235 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38236 int result;
38237 PyObject * obj0 = 0 ;
38238 char *kwnames[] = {
38239 (char *) "self", NULL
38240 };
38241
38242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38244 if (SWIG_arg_fail(1)) SWIG_fail;
38245 {
38246 PyThreadState* __tstate = wxPyBeginAllowThreads();
38247 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38248
38249 wxPyEndAllowThreads(__tstate);
38250 if (PyErr_Occurred()) SWIG_fail;
38251 }
38252 {
38253 resultobj = SWIG_From_int((int)(result));
38254 }
38255 return resultobj;
38256 fail:
38257 return NULL;
38258 }
38259
38260
38261 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38262 PyObject *resultobj;
38263 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38264 wxString *arg2 = 0 ;
38265 bool result;
38266 bool temp2 = false ;
38267 PyObject * obj0 = 0 ;
38268 PyObject * obj1 = 0 ;
38269 char *kwnames[] = {
38270 (char *) "self",(char *) "s", NULL
38271 };
38272
38273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
38278 if (arg2 == NULL) SWIG_fail;
38279 temp2 = true;
38280 }
38281 {
38282 PyThreadState* __tstate = wxPyBeginAllowThreads();
38283 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38284
38285 wxPyEndAllowThreads(__tstate);
38286 if (PyErr_Occurred()) SWIG_fail;
38287 }
38288 {
38289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38290 }
38291 {
38292 if (temp2)
38293 delete arg2;
38294 }
38295 return resultobj;
38296 fail:
38297 {
38298 if (temp2)
38299 delete arg2;
38300 }
38301 return NULL;
38302 }
38303
38304
38305 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38306 PyObject *resultobj;
38307 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38308 wxString result;
38309 PyObject * obj0 = 0 ;
38310 char *kwnames[] = {
38311 (char *) "self", NULL
38312 };
38313
38314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38316 if (SWIG_arg_fail(1)) SWIG_fail;
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38320
38321 wxPyEndAllowThreads(__tstate);
38322 if (PyErr_Occurred()) SWIG_fail;
38323 }
38324 {
38325 #if wxUSE_UNICODE
38326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38327 #else
38328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38329 #endif
38330 }
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38338 PyObject *resultobj;
38339 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38340 int arg2 ;
38341 PyObject * obj0 = 0 ;
38342 PyObject * obj1 = 0 ;
38343 char *kwnames[] = {
38344 (char *) "self",(char *) "n", NULL
38345 };
38346
38347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38349 if (SWIG_arg_fail(1)) SWIG_fail;
38350 {
38351 arg2 = (int)(SWIG_As_int(obj1));
38352 if (SWIG_arg_fail(2)) SWIG_fail;
38353 }
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 (arg1)->Select(arg2);
38357
38358 wxPyEndAllowThreads(__tstate);
38359 if (PyErr_Occurred()) SWIG_fail;
38360 }
38361 Py_INCREF(Py_None); resultobj = Py_None;
38362 return resultobj;
38363 fail:
38364 return NULL;
38365 }
38366
38367
38368 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38369 PyObject *obj;
38370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38371 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38372 Py_INCREF(obj);
38373 return Py_BuildValue((char *)"");
38374 }
38375 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38376 PyObject *obj;
38377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38378 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38379 Py_INCREF(obj);
38380 return Py_BuildValue((char *)"");
38381 }
38382 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38383 PyObject *resultobj;
38384 wxSizerItem *result;
38385 char *kwnames[] = {
38386 NULL
38387 };
38388
38389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38390 {
38391 PyThreadState* __tstate = wxPyBeginAllowThreads();
38392 result = (wxSizerItem *)new wxSizerItem();
38393
38394 wxPyEndAllowThreads(__tstate);
38395 if (PyErr_Occurred()) SWIG_fail;
38396 }
38397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38398 return resultobj;
38399 fail:
38400 return NULL;
38401 }
38402
38403
38404 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38405 PyObject *resultobj;
38406 wxWindow *arg1 = (wxWindow *) 0 ;
38407 int arg2 ;
38408 int arg3 ;
38409 int arg4 ;
38410 PyObject *arg5 = (PyObject *) NULL ;
38411 wxSizerItem *result;
38412 PyObject * obj0 = 0 ;
38413 PyObject * obj1 = 0 ;
38414 PyObject * obj2 = 0 ;
38415 PyObject * obj3 = 0 ;
38416 PyObject * obj4 = 0 ;
38417 char *kwnames[] = {
38418 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38419 };
38420
38421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38423 if (SWIG_arg_fail(1)) SWIG_fail;
38424 {
38425 arg2 = (int)(SWIG_As_int(obj1));
38426 if (SWIG_arg_fail(2)) SWIG_fail;
38427 }
38428 {
38429 arg3 = (int)(SWIG_As_int(obj2));
38430 if (SWIG_arg_fail(3)) SWIG_fail;
38431 }
38432 {
38433 arg4 = (int)(SWIG_As_int(obj3));
38434 if (SWIG_arg_fail(4)) SWIG_fail;
38435 }
38436 if (obj4) {
38437 arg5 = obj4;
38438 }
38439 {
38440 PyThreadState* __tstate = wxPyBeginAllowThreads();
38441 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38442
38443 wxPyEndAllowThreads(__tstate);
38444 if (PyErr_Occurred()) SWIG_fail;
38445 }
38446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj;
38455 int arg1 ;
38456 int arg2 ;
38457 int arg3 ;
38458 int arg4 ;
38459 int arg5 ;
38460 PyObject *arg6 = (PyObject *) NULL ;
38461 wxSizerItem *result;
38462 PyObject * obj0 = 0 ;
38463 PyObject * obj1 = 0 ;
38464 PyObject * obj2 = 0 ;
38465 PyObject * obj3 = 0 ;
38466 PyObject * obj4 = 0 ;
38467 PyObject * obj5 = 0 ;
38468 char *kwnames[] = {
38469 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38470 };
38471
38472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38473 {
38474 arg1 = (int)(SWIG_As_int(obj0));
38475 if (SWIG_arg_fail(1)) SWIG_fail;
38476 }
38477 {
38478 arg2 = (int)(SWIG_As_int(obj1));
38479 if (SWIG_arg_fail(2)) SWIG_fail;
38480 }
38481 {
38482 arg3 = (int)(SWIG_As_int(obj2));
38483 if (SWIG_arg_fail(3)) SWIG_fail;
38484 }
38485 {
38486 arg4 = (int)(SWIG_As_int(obj3));
38487 if (SWIG_arg_fail(4)) SWIG_fail;
38488 }
38489 {
38490 arg5 = (int)(SWIG_As_int(obj4));
38491 if (SWIG_arg_fail(5)) SWIG_fail;
38492 }
38493 if (obj5) {
38494 arg6 = obj5;
38495 }
38496 {
38497 PyThreadState* __tstate = wxPyBeginAllowThreads();
38498 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38499
38500 wxPyEndAllowThreads(__tstate);
38501 if (PyErr_Occurred()) SWIG_fail;
38502 }
38503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38504 return resultobj;
38505 fail:
38506 return NULL;
38507 }
38508
38509
38510 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj;
38512 wxSizer *arg1 = (wxSizer *) 0 ;
38513 int arg2 ;
38514 int arg3 ;
38515 int arg4 ;
38516 PyObject *arg5 = (PyObject *) NULL ;
38517 wxSizerItem *result;
38518 PyObject * obj0 = 0 ;
38519 PyObject * obj1 = 0 ;
38520 PyObject * obj2 = 0 ;
38521 PyObject * obj3 = 0 ;
38522 PyObject * obj4 = 0 ;
38523 char *kwnames[] = {
38524 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38525 };
38526
38527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38529 if (SWIG_arg_fail(1)) SWIG_fail;
38530 {
38531 arg2 = (int)(SWIG_As_int(obj1));
38532 if (SWIG_arg_fail(2)) SWIG_fail;
38533 }
38534 {
38535 arg3 = (int)(SWIG_As_int(obj2));
38536 if (SWIG_arg_fail(3)) SWIG_fail;
38537 }
38538 {
38539 arg4 = (int)(SWIG_As_int(obj3));
38540 if (SWIG_arg_fail(4)) SWIG_fail;
38541 }
38542 if (obj4) {
38543 arg5 = obj4;
38544 }
38545 {
38546 PyThreadState* __tstate = wxPyBeginAllowThreads();
38547 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38548
38549 wxPyEndAllowThreads(__tstate);
38550 if (PyErr_Occurred()) SWIG_fail;
38551 }
38552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj;
38561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38562 PyObject * obj0 = 0 ;
38563 char *kwnames[] = {
38564 (char *) "self", NULL
38565 };
38566
38567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38569 if (SWIG_arg_fail(1)) SWIG_fail;
38570 {
38571 PyThreadState* __tstate = wxPyBeginAllowThreads();
38572 (arg1)->DeleteWindows();
38573
38574 wxPyEndAllowThreads(__tstate);
38575 if (PyErr_Occurred()) SWIG_fail;
38576 }
38577 Py_INCREF(Py_None); resultobj = Py_None;
38578 return resultobj;
38579 fail:
38580 return NULL;
38581 }
38582
38583
38584 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38585 PyObject *resultobj;
38586 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38587 PyObject * obj0 = 0 ;
38588 char *kwnames[] = {
38589 (char *) "self", NULL
38590 };
38591
38592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38594 if (SWIG_arg_fail(1)) SWIG_fail;
38595 {
38596 PyThreadState* __tstate = wxPyBeginAllowThreads();
38597 (arg1)->DetachSizer();
38598
38599 wxPyEndAllowThreads(__tstate);
38600 if (PyErr_Occurred()) SWIG_fail;
38601 }
38602 Py_INCREF(Py_None); resultobj = Py_None;
38603 return resultobj;
38604 fail:
38605 return NULL;
38606 }
38607
38608
38609 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38610 PyObject *resultobj;
38611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38612 wxSize result;
38613 PyObject * obj0 = 0 ;
38614 char *kwnames[] = {
38615 (char *) "self", NULL
38616 };
38617
38618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38620 if (SWIG_arg_fail(1)) SWIG_fail;
38621 {
38622 PyThreadState* __tstate = wxPyBeginAllowThreads();
38623 result = (arg1)->GetSize();
38624
38625 wxPyEndAllowThreads(__tstate);
38626 if (PyErr_Occurred()) SWIG_fail;
38627 }
38628 {
38629 wxSize * resultptr;
38630 resultptr = new wxSize((wxSize &)(result));
38631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38632 }
38633 return resultobj;
38634 fail:
38635 return NULL;
38636 }
38637
38638
38639 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38640 PyObject *resultobj;
38641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38642 wxSize result;
38643 PyObject * obj0 = 0 ;
38644 char *kwnames[] = {
38645 (char *) "self", NULL
38646 };
38647
38648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38650 if (SWIG_arg_fail(1)) SWIG_fail;
38651 {
38652 PyThreadState* __tstate = wxPyBeginAllowThreads();
38653 result = (arg1)->CalcMin();
38654
38655 wxPyEndAllowThreads(__tstate);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 }
38658 {
38659 wxSize * resultptr;
38660 resultptr = new wxSize((wxSize &)(result));
38661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38662 }
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38670 PyObject *resultobj;
38671 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38672 wxPoint arg2 ;
38673 wxSize arg3 ;
38674 PyObject * obj0 = 0 ;
38675 PyObject * obj1 = 0 ;
38676 PyObject * obj2 = 0 ;
38677 char *kwnames[] = {
38678 (char *) "self",(char *) "pos",(char *) "size", NULL
38679 };
38680
38681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38683 if (SWIG_arg_fail(1)) SWIG_fail;
38684 {
38685 wxPoint * argp;
38686 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38687 if (SWIG_arg_fail(2)) SWIG_fail;
38688 if (argp == NULL) {
38689 SWIG_null_ref("wxPoint");
38690 }
38691 if (SWIG_arg_fail(2)) SWIG_fail;
38692 arg2 = *argp;
38693 }
38694 {
38695 wxSize * argp;
38696 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38697 if (SWIG_arg_fail(3)) SWIG_fail;
38698 if (argp == NULL) {
38699 SWIG_null_ref("wxSize");
38700 }
38701 if (SWIG_arg_fail(3)) SWIG_fail;
38702 arg3 = *argp;
38703 }
38704 {
38705 PyThreadState* __tstate = wxPyBeginAllowThreads();
38706 (arg1)->SetDimension(arg2,arg3);
38707
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 Py_INCREF(Py_None); resultobj = Py_None;
38712 return resultobj;
38713 fail:
38714 return NULL;
38715 }
38716
38717
38718 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj;
38720 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38721 wxSize result;
38722 PyObject * obj0 = 0 ;
38723 char *kwnames[] = {
38724 (char *) "self", NULL
38725 };
38726
38727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38729 if (SWIG_arg_fail(1)) SWIG_fail;
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 result = (arg1)->GetMinSize();
38733
38734 wxPyEndAllowThreads(__tstate);
38735 if (PyErr_Occurred()) SWIG_fail;
38736 }
38737 {
38738 wxSize * resultptr;
38739 resultptr = new wxSize((wxSize &)(result));
38740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38741 }
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38749 PyObject *resultobj;
38750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38751 wxSize result;
38752 PyObject * obj0 = 0 ;
38753 char *kwnames[] = {
38754 (char *) "self", NULL
38755 };
38756
38757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38759 if (SWIG_arg_fail(1)) SWIG_fail;
38760 {
38761 PyThreadState* __tstate = wxPyBeginAllowThreads();
38762 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38763
38764 wxPyEndAllowThreads(__tstate);
38765 if (PyErr_Occurred()) SWIG_fail;
38766 }
38767 {
38768 wxSize * resultptr;
38769 resultptr = new wxSize((wxSize &)(result));
38770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38771 }
38772 return resultobj;
38773 fail:
38774 return NULL;
38775 }
38776
38777
38778 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38779 PyObject *resultobj;
38780 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38781 int arg2 ;
38782 int arg3 ;
38783 PyObject * obj0 = 0 ;
38784 PyObject * obj1 = 0 ;
38785 PyObject * obj2 = 0 ;
38786 char *kwnames[] = {
38787 (char *) "self",(char *) "x",(char *) "y", NULL
38788 };
38789
38790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38792 if (SWIG_arg_fail(1)) SWIG_fail;
38793 {
38794 arg2 = (int)(SWIG_As_int(obj1));
38795 if (SWIG_arg_fail(2)) SWIG_fail;
38796 }
38797 {
38798 arg3 = (int)(SWIG_As_int(obj2));
38799 if (SWIG_arg_fail(3)) SWIG_fail;
38800 }
38801 {
38802 PyThreadState* __tstate = wxPyBeginAllowThreads();
38803 (arg1)->SetInitSize(arg2,arg3);
38804
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 Py_INCREF(Py_None); resultobj = Py_None;
38809 return resultobj;
38810 fail:
38811 return NULL;
38812 }
38813
38814
38815 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj;
38817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38818 int arg2 ;
38819 int arg3 ;
38820 PyObject * obj0 = 0 ;
38821 PyObject * obj1 = 0 ;
38822 PyObject * obj2 = 0 ;
38823 char *kwnames[] = {
38824 (char *) "self",(char *) "width",(char *) "height", NULL
38825 };
38826
38827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38829 if (SWIG_arg_fail(1)) SWIG_fail;
38830 {
38831 arg2 = (int)(SWIG_As_int(obj1));
38832 if (SWIG_arg_fail(2)) SWIG_fail;
38833 }
38834 {
38835 arg3 = (int)(SWIG_As_int(obj2));
38836 if (SWIG_arg_fail(3)) SWIG_fail;
38837 }
38838 {
38839 PyThreadState* __tstate = wxPyBeginAllowThreads();
38840 (arg1)->SetRatio(arg2,arg3);
38841
38842 wxPyEndAllowThreads(__tstate);
38843 if (PyErr_Occurred()) SWIG_fail;
38844 }
38845 Py_INCREF(Py_None); resultobj = Py_None;
38846 return resultobj;
38847 fail:
38848 return NULL;
38849 }
38850
38851
38852 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38853 PyObject *resultobj;
38854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38855 wxSize *arg2 = 0 ;
38856 wxSize temp2 ;
38857 PyObject * obj0 = 0 ;
38858 PyObject * obj1 = 0 ;
38859 char *kwnames[] = {
38860 (char *) "self",(char *) "size", NULL
38861 };
38862
38863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38865 if (SWIG_arg_fail(1)) SWIG_fail;
38866 {
38867 arg2 = &temp2;
38868 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38869 }
38870 {
38871 PyThreadState* __tstate = wxPyBeginAllowThreads();
38872 (arg1)->SetRatio((wxSize const &)*arg2);
38873
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 Py_INCREF(Py_None); resultobj = Py_None;
38878 return resultobj;
38879 fail:
38880 return NULL;
38881 }
38882
38883
38884 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38885 PyObject *resultobj;
38886 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38887 float arg2 ;
38888 PyObject * obj0 = 0 ;
38889 PyObject * obj1 = 0 ;
38890 char *kwnames[] = {
38891 (char *) "self",(char *) "ratio", NULL
38892 };
38893
38894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",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 = (float)(SWIG_As_float(obj1));
38899 if (SWIG_arg_fail(2)) SWIG_fail;
38900 }
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 (arg1)->SetRatio(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_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38916 PyObject *resultobj;
38917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38918 float result;
38919 PyObject * obj0 = 0 ;
38920 char *kwnames[] = {
38921 (char *) "self", NULL
38922 };
38923
38924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38926 if (SWIG_arg_fail(1)) SWIG_fail;
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (float)(arg1)->GetRatio();
38930
38931 wxPyEndAllowThreads(__tstate);
38932 if (PyErr_Occurred()) SWIG_fail;
38933 }
38934 {
38935 resultobj = SWIG_From_float((float)(result));
38936 }
38937 return resultobj;
38938 fail:
38939 return NULL;
38940 }
38941
38942
38943 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38944 PyObject *resultobj;
38945 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38946 wxRect result;
38947 PyObject * obj0 = 0 ;
38948 char *kwnames[] = {
38949 (char *) "self", NULL
38950 };
38951
38952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38954 if (SWIG_arg_fail(1)) SWIG_fail;
38955 {
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 result = (arg1)->GetRect();
38958
38959 wxPyEndAllowThreads(__tstate);
38960 if (PyErr_Occurred()) SWIG_fail;
38961 }
38962 {
38963 wxRect * resultptr;
38964 resultptr = new wxRect((wxRect &)(result));
38965 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38966 }
38967 return resultobj;
38968 fail:
38969 return NULL;
38970 }
38971
38972
38973 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38974 PyObject *resultobj;
38975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38976 bool result;
38977 PyObject * obj0 = 0 ;
38978 char *kwnames[] = {
38979 (char *) "self", NULL
38980 };
38981
38982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38984 if (SWIG_arg_fail(1)) SWIG_fail;
38985 {
38986 PyThreadState* __tstate = wxPyBeginAllowThreads();
38987 result = (bool)(arg1)->IsWindow();
38988
38989 wxPyEndAllowThreads(__tstate);
38990 if (PyErr_Occurred()) SWIG_fail;
38991 }
38992 {
38993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38994 }
38995 return resultobj;
38996 fail:
38997 return NULL;
38998 }
38999
39000
39001 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39002 PyObject *resultobj;
39003 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39004 bool result;
39005 PyObject * obj0 = 0 ;
39006 char *kwnames[] = {
39007 (char *) "self", NULL
39008 };
39009
39010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39012 if (SWIG_arg_fail(1)) SWIG_fail;
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = (bool)(arg1)->IsSizer();
39016
39017 wxPyEndAllowThreads(__tstate);
39018 if (PyErr_Occurred()) SWIG_fail;
39019 }
39020 {
39021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39022 }
39023 return resultobj;
39024 fail:
39025 return NULL;
39026 }
39027
39028
39029 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39030 PyObject *resultobj;
39031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39032 bool result;
39033 PyObject * obj0 = 0 ;
39034 char *kwnames[] = {
39035 (char *) "self", NULL
39036 };
39037
39038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39040 if (SWIG_arg_fail(1)) SWIG_fail;
39041 {
39042 PyThreadState* __tstate = wxPyBeginAllowThreads();
39043 result = (bool)(arg1)->IsSpacer();
39044
39045 wxPyEndAllowThreads(__tstate);
39046 if (PyErr_Occurred()) SWIG_fail;
39047 }
39048 {
39049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39050 }
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39058 PyObject *resultobj;
39059 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39060 int arg2 ;
39061 PyObject * obj0 = 0 ;
39062 PyObject * obj1 = 0 ;
39063 char *kwnames[] = {
39064 (char *) "self",(char *) "proportion", NULL
39065 };
39066
39067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39069 if (SWIG_arg_fail(1)) SWIG_fail;
39070 {
39071 arg2 = (int)(SWIG_As_int(obj1));
39072 if (SWIG_arg_fail(2)) SWIG_fail;
39073 }
39074 {
39075 PyThreadState* __tstate = wxPyBeginAllowThreads();
39076 (arg1)->SetProportion(arg2);
39077
39078 wxPyEndAllowThreads(__tstate);
39079 if (PyErr_Occurred()) SWIG_fail;
39080 }
39081 Py_INCREF(Py_None); resultobj = Py_None;
39082 return resultobj;
39083 fail:
39084 return NULL;
39085 }
39086
39087
39088 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39089 PyObject *resultobj;
39090 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39091 int result;
39092 PyObject * obj0 = 0 ;
39093 char *kwnames[] = {
39094 (char *) "self", NULL
39095 };
39096
39097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39099 if (SWIG_arg_fail(1)) SWIG_fail;
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 result = (int)(arg1)->GetProportion();
39103
39104 wxPyEndAllowThreads(__tstate);
39105 if (PyErr_Occurred()) SWIG_fail;
39106 }
39107 {
39108 resultobj = SWIG_From_int((int)(result));
39109 }
39110 return resultobj;
39111 fail:
39112 return NULL;
39113 }
39114
39115
39116 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39117 PyObject *resultobj;
39118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39119 int arg2 ;
39120 PyObject * obj0 = 0 ;
39121 PyObject * obj1 = 0 ;
39122 char *kwnames[] = {
39123 (char *) "self",(char *) "flag", NULL
39124 };
39125
39126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39128 if (SWIG_arg_fail(1)) SWIG_fail;
39129 {
39130 arg2 = (int)(SWIG_As_int(obj1));
39131 if (SWIG_arg_fail(2)) SWIG_fail;
39132 }
39133 {
39134 PyThreadState* __tstate = wxPyBeginAllowThreads();
39135 (arg1)->SetFlag(arg2);
39136
39137 wxPyEndAllowThreads(__tstate);
39138 if (PyErr_Occurred()) SWIG_fail;
39139 }
39140 Py_INCREF(Py_None); resultobj = Py_None;
39141 return resultobj;
39142 fail:
39143 return NULL;
39144 }
39145
39146
39147 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj;
39149 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39150 int result;
39151 PyObject * obj0 = 0 ;
39152 char *kwnames[] = {
39153 (char *) "self", NULL
39154 };
39155
39156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39158 if (SWIG_arg_fail(1)) SWIG_fail;
39159 {
39160 PyThreadState* __tstate = wxPyBeginAllowThreads();
39161 result = (int)(arg1)->GetFlag();
39162
39163 wxPyEndAllowThreads(__tstate);
39164 if (PyErr_Occurred()) SWIG_fail;
39165 }
39166 {
39167 resultobj = SWIG_From_int((int)(result));
39168 }
39169 return resultobj;
39170 fail:
39171 return NULL;
39172 }
39173
39174
39175 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj;
39177 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39178 int arg2 ;
39179 PyObject * obj0 = 0 ;
39180 PyObject * obj1 = 0 ;
39181 char *kwnames[] = {
39182 (char *) "self",(char *) "border", NULL
39183 };
39184
39185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39187 if (SWIG_arg_fail(1)) SWIG_fail;
39188 {
39189 arg2 = (int)(SWIG_As_int(obj1));
39190 if (SWIG_arg_fail(2)) SWIG_fail;
39191 }
39192 {
39193 PyThreadState* __tstate = wxPyBeginAllowThreads();
39194 (arg1)->SetBorder(arg2);
39195
39196 wxPyEndAllowThreads(__tstate);
39197 if (PyErr_Occurred()) SWIG_fail;
39198 }
39199 Py_INCREF(Py_None); resultobj = Py_None;
39200 return resultobj;
39201 fail:
39202 return NULL;
39203 }
39204
39205
39206 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39207 PyObject *resultobj;
39208 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39209 int result;
39210 PyObject * obj0 = 0 ;
39211 char *kwnames[] = {
39212 (char *) "self", NULL
39213 };
39214
39215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39217 if (SWIG_arg_fail(1)) SWIG_fail;
39218 {
39219 PyThreadState* __tstate = wxPyBeginAllowThreads();
39220 result = (int)(arg1)->GetBorder();
39221
39222 wxPyEndAllowThreads(__tstate);
39223 if (PyErr_Occurred()) SWIG_fail;
39224 }
39225 {
39226 resultobj = SWIG_From_int((int)(result));
39227 }
39228 return resultobj;
39229 fail:
39230 return NULL;
39231 }
39232
39233
39234 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39235 PyObject *resultobj;
39236 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39237 wxWindow *result;
39238 PyObject * obj0 = 0 ;
39239 char *kwnames[] = {
39240 (char *) "self", NULL
39241 };
39242
39243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39245 if (SWIG_arg_fail(1)) SWIG_fail;
39246 {
39247 PyThreadState* __tstate = wxPyBeginAllowThreads();
39248 result = (wxWindow *)(arg1)->GetWindow();
39249
39250 wxPyEndAllowThreads(__tstate);
39251 if (PyErr_Occurred()) SWIG_fail;
39252 }
39253 {
39254 resultobj = wxPyMake_wxObject(result, 0);
39255 }
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39263 PyObject *resultobj;
39264 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39265 wxWindow *arg2 = (wxWindow *) 0 ;
39266 PyObject * obj0 = 0 ;
39267 PyObject * obj1 = 0 ;
39268 char *kwnames[] = {
39269 (char *) "self",(char *) "window", NULL
39270 };
39271
39272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39274 if (SWIG_arg_fail(1)) SWIG_fail;
39275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39276 if (SWIG_arg_fail(2)) SWIG_fail;
39277 {
39278 PyThreadState* __tstate = wxPyBeginAllowThreads();
39279 (arg1)->SetWindow(arg2);
39280
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 Py_INCREF(Py_None); resultobj = Py_None;
39285 return resultobj;
39286 fail:
39287 return NULL;
39288 }
39289
39290
39291 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39292 PyObject *resultobj;
39293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39294 wxSizer *result;
39295 PyObject * obj0 = 0 ;
39296 char *kwnames[] = {
39297 (char *) "self", NULL
39298 };
39299
39300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39302 if (SWIG_arg_fail(1)) SWIG_fail;
39303 {
39304 PyThreadState* __tstate = wxPyBeginAllowThreads();
39305 result = (wxSizer *)(arg1)->GetSizer();
39306
39307 wxPyEndAllowThreads(__tstate);
39308 if (PyErr_Occurred()) SWIG_fail;
39309 }
39310 {
39311 resultobj = wxPyMake_wxObject(result, 0);
39312 }
39313 return resultobj;
39314 fail:
39315 return NULL;
39316 }
39317
39318
39319 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39320 PyObject *resultobj;
39321 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39322 wxSizer *arg2 = (wxSizer *) 0 ;
39323 PyObject * obj0 = 0 ;
39324 PyObject * obj1 = 0 ;
39325 char *kwnames[] = {
39326 (char *) "self",(char *) "sizer", NULL
39327 };
39328
39329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39331 if (SWIG_arg_fail(1)) SWIG_fail;
39332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39333 if (SWIG_arg_fail(2)) SWIG_fail;
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 (arg1)->SetSizer(arg2);
39337
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 Py_INCREF(Py_None); resultobj = Py_None;
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39349 PyObject *resultobj;
39350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39351 wxSize *result;
39352 PyObject * obj0 = 0 ;
39353 char *kwnames[] = {
39354 (char *) "self", NULL
39355 };
39356
39357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39359 if (SWIG_arg_fail(1)) SWIG_fail;
39360 {
39361 PyThreadState* __tstate = wxPyBeginAllowThreads();
39362 {
39363 wxSize const &_result_ref = (arg1)->GetSpacer();
39364 result = (wxSize *) &_result_ref;
39365 }
39366
39367 wxPyEndAllowThreads(__tstate);
39368 if (PyErr_Occurred()) SWIG_fail;
39369 }
39370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39371 return resultobj;
39372 fail:
39373 return NULL;
39374 }
39375
39376
39377 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39378 PyObject *resultobj;
39379 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39380 wxSize *arg2 = 0 ;
39381 wxSize temp2 ;
39382 PyObject * obj0 = 0 ;
39383 PyObject * obj1 = 0 ;
39384 char *kwnames[] = {
39385 (char *) "self",(char *) "size", NULL
39386 };
39387
39388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
39393 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39394 }
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 (arg1)->SetSpacer((wxSize const &)*arg2);
39398
39399 wxPyEndAllowThreads(__tstate);
39400 if (PyErr_Occurred()) SWIG_fail;
39401 }
39402 Py_INCREF(Py_None); resultobj = Py_None;
39403 return resultobj;
39404 fail:
39405 return NULL;
39406 }
39407
39408
39409 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39410 PyObject *resultobj;
39411 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39412 bool arg2 ;
39413 PyObject * obj0 = 0 ;
39414 PyObject * obj1 = 0 ;
39415 char *kwnames[] = {
39416 (char *) "self",(char *) "show", NULL
39417 };
39418
39419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",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 = (bool)(SWIG_As_bool(obj1));
39424 if (SWIG_arg_fail(2)) SWIG_fail;
39425 }
39426 {
39427 PyThreadState* __tstate = wxPyBeginAllowThreads();
39428 (arg1)->Show(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_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj;
39442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39443 bool result;
39444 PyObject * obj0 = 0 ;
39445 char *kwnames[] = {
39446 (char *) "self", NULL
39447 };
39448
39449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39451 if (SWIG_arg_fail(1)) SWIG_fail;
39452 {
39453 PyThreadState* __tstate = wxPyBeginAllowThreads();
39454 result = (bool)(arg1)->IsShown();
39455
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 {
39460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39461 }
39462 return resultobj;
39463 fail:
39464 return NULL;
39465 }
39466
39467
39468 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39469 PyObject *resultobj;
39470 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39471 wxPoint result;
39472 PyObject * obj0 = 0 ;
39473 char *kwnames[] = {
39474 (char *) "self", NULL
39475 };
39476
39477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39479 if (SWIG_arg_fail(1)) SWIG_fail;
39480 {
39481 PyThreadState* __tstate = wxPyBeginAllowThreads();
39482 result = (arg1)->GetPosition();
39483
39484 wxPyEndAllowThreads(__tstate);
39485 if (PyErr_Occurred()) SWIG_fail;
39486 }
39487 {
39488 wxPoint * resultptr;
39489 resultptr = new wxPoint((wxPoint &)(result));
39490 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39491 }
39492 return resultobj;
39493 fail:
39494 return NULL;
39495 }
39496
39497
39498 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39499 PyObject *resultobj;
39500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39501 PyObject *result;
39502 PyObject * obj0 = 0 ;
39503 char *kwnames[] = {
39504 (char *) "self", NULL
39505 };
39506
39507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39509 if (SWIG_arg_fail(1)) SWIG_fail;
39510 {
39511 PyThreadState* __tstate = wxPyBeginAllowThreads();
39512 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39513
39514 wxPyEndAllowThreads(__tstate);
39515 if (PyErr_Occurred()) SWIG_fail;
39516 }
39517 resultobj = result;
39518 return resultobj;
39519 fail:
39520 return NULL;
39521 }
39522
39523
39524 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39525 PyObject *obj;
39526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39527 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39528 Py_INCREF(obj);
39529 return Py_BuildValue((char *)"");
39530 }
39531 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39532 PyObject *resultobj;
39533 wxSizer *arg1 = (wxSizer *) 0 ;
39534 PyObject *arg2 = (PyObject *) 0 ;
39535 PyObject * obj0 = 0 ;
39536 PyObject * obj1 = 0 ;
39537 char *kwnames[] = {
39538 (char *) "self",(char *) "_self", NULL
39539 };
39540
39541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39543 if (SWIG_arg_fail(1)) SWIG_fail;
39544 arg2 = obj1;
39545 {
39546 PyThreadState* __tstate = wxPyBeginAllowThreads();
39547 wxSizer__setOORInfo(arg1,arg2);
39548
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 Py_INCREF(Py_None); resultobj = Py_None;
39553 return resultobj;
39554 fail:
39555 return NULL;
39556 }
39557
39558
39559 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39560 PyObject *resultobj;
39561 wxSizer *arg1 = (wxSizer *) 0 ;
39562 PyObject *arg2 = (PyObject *) 0 ;
39563 int arg3 = (int) 0 ;
39564 int arg4 = (int) 0 ;
39565 int arg5 = (int) 0 ;
39566 PyObject *arg6 = (PyObject *) NULL ;
39567 wxSizerItem *result;
39568 PyObject * obj0 = 0 ;
39569 PyObject * obj1 = 0 ;
39570 PyObject * obj2 = 0 ;
39571 PyObject * obj3 = 0 ;
39572 PyObject * obj4 = 0 ;
39573 PyObject * obj5 = 0 ;
39574 char *kwnames[] = {
39575 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39576 };
39577
39578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39580 if (SWIG_arg_fail(1)) SWIG_fail;
39581 arg2 = obj1;
39582 if (obj2) {
39583 {
39584 arg3 = (int)(SWIG_As_int(obj2));
39585 if (SWIG_arg_fail(3)) SWIG_fail;
39586 }
39587 }
39588 if (obj3) {
39589 {
39590 arg4 = (int)(SWIG_As_int(obj3));
39591 if (SWIG_arg_fail(4)) SWIG_fail;
39592 }
39593 }
39594 if (obj4) {
39595 {
39596 arg5 = (int)(SWIG_As_int(obj4));
39597 if (SWIG_arg_fail(5)) SWIG_fail;
39598 }
39599 }
39600 if (obj5) {
39601 arg6 = obj5;
39602 }
39603 {
39604 PyThreadState* __tstate = wxPyBeginAllowThreads();
39605 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39606
39607 wxPyEndAllowThreads(__tstate);
39608 if (PyErr_Occurred()) SWIG_fail;
39609 }
39610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39618 PyObject *resultobj;
39619 wxSizer *arg1 = (wxSizer *) 0 ;
39620 int arg2 ;
39621 PyObject *arg3 = (PyObject *) 0 ;
39622 int arg4 = (int) 0 ;
39623 int arg5 = (int) 0 ;
39624 int arg6 = (int) 0 ;
39625 PyObject *arg7 = (PyObject *) NULL ;
39626 wxSizerItem *result;
39627 PyObject * obj0 = 0 ;
39628 PyObject * obj1 = 0 ;
39629 PyObject * obj2 = 0 ;
39630 PyObject * obj3 = 0 ;
39631 PyObject * obj4 = 0 ;
39632 PyObject * obj5 = 0 ;
39633 PyObject * obj6 = 0 ;
39634 char *kwnames[] = {
39635 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39636 };
39637
39638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39640 if (SWIG_arg_fail(1)) SWIG_fail;
39641 {
39642 arg2 = (int)(SWIG_As_int(obj1));
39643 if (SWIG_arg_fail(2)) SWIG_fail;
39644 }
39645 arg3 = obj2;
39646 if (obj3) {
39647 {
39648 arg4 = (int)(SWIG_As_int(obj3));
39649 if (SWIG_arg_fail(4)) SWIG_fail;
39650 }
39651 }
39652 if (obj4) {
39653 {
39654 arg5 = (int)(SWIG_As_int(obj4));
39655 if (SWIG_arg_fail(5)) SWIG_fail;
39656 }
39657 }
39658 if (obj5) {
39659 {
39660 arg6 = (int)(SWIG_As_int(obj5));
39661 if (SWIG_arg_fail(6)) SWIG_fail;
39662 }
39663 }
39664 if (obj6) {
39665 arg7 = obj6;
39666 }
39667 {
39668 PyThreadState* __tstate = wxPyBeginAllowThreads();
39669 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39670
39671 wxPyEndAllowThreads(__tstate);
39672 if (PyErr_Occurred()) SWIG_fail;
39673 }
39674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39675 return resultobj;
39676 fail:
39677 return NULL;
39678 }
39679
39680
39681 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39682 PyObject *resultobj;
39683 wxSizer *arg1 = (wxSizer *) 0 ;
39684 PyObject *arg2 = (PyObject *) 0 ;
39685 int arg3 = (int) 0 ;
39686 int arg4 = (int) 0 ;
39687 int arg5 = (int) 0 ;
39688 PyObject *arg6 = (PyObject *) NULL ;
39689 wxSizerItem *result;
39690 PyObject * obj0 = 0 ;
39691 PyObject * obj1 = 0 ;
39692 PyObject * obj2 = 0 ;
39693 PyObject * obj3 = 0 ;
39694 PyObject * obj4 = 0 ;
39695 PyObject * obj5 = 0 ;
39696 char *kwnames[] = {
39697 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39698 };
39699
39700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39702 if (SWIG_arg_fail(1)) SWIG_fail;
39703 arg2 = obj1;
39704 if (obj2) {
39705 {
39706 arg3 = (int)(SWIG_As_int(obj2));
39707 if (SWIG_arg_fail(3)) SWIG_fail;
39708 }
39709 }
39710 if (obj3) {
39711 {
39712 arg4 = (int)(SWIG_As_int(obj3));
39713 if (SWIG_arg_fail(4)) SWIG_fail;
39714 }
39715 }
39716 if (obj4) {
39717 {
39718 arg5 = (int)(SWIG_As_int(obj4));
39719 if (SWIG_arg_fail(5)) SWIG_fail;
39720 }
39721 }
39722 if (obj5) {
39723 arg6 = obj5;
39724 }
39725 {
39726 PyThreadState* __tstate = wxPyBeginAllowThreads();
39727 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39728
39729 wxPyEndAllowThreads(__tstate);
39730 if (PyErr_Occurred()) SWIG_fail;
39731 }
39732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39733 return resultobj;
39734 fail:
39735 return NULL;
39736 }
39737
39738
39739 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39740 PyObject *resultobj;
39741 wxSizer *arg1 = (wxSizer *) 0 ;
39742 PyObject *arg2 = (PyObject *) 0 ;
39743 bool result;
39744 PyObject * obj0 = 0 ;
39745 PyObject * obj1 = 0 ;
39746 char *kwnames[] = {
39747 (char *) "self",(char *) "item", NULL
39748 };
39749
39750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39752 if (SWIG_arg_fail(1)) SWIG_fail;
39753 arg2 = obj1;
39754 {
39755 PyThreadState* __tstate = wxPyBeginAllowThreads();
39756 result = (bool)wxSizer_Remove(arg1,arg2);
39757
39758 wxPyEndAllowThreads(__tstate);
39759 if (PyErr_Occurred()) SWIG_fail;
39760 }
39761 {
39762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39763 }
39764 return resultobj;
39765 fail:
39766 return NULL;
39767 }
39768
39769
39770 static PyObject *_wrap_Sizer_Detach(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_Detach",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_Detach(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_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39802 PyObject *resultobj;
39803 wxSizer *arg1 = (wxSizer *) 0 ;
39804 PyObject *arg2 = (PyObject *) 0 ;
39805 wxSizerItem *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_GetItem",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 = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39819
39820 wxPyEndAllowThreads(__tstate);
39821 if (PyErr_Occurred()) SWIG_fail;
39822 }
39823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39824 return resultobj;
39825 fail:
39826 return NULL;
39827 }
39828
39829
39830 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39831 PyObject *resultobj;
39832 wxSizer *arg1 = (wxSizer *) 0 ;
39833 PyObject *arg2 = (PyObject *) 0 ;
39834 wxSize *arg3 = 0 ;
39835 wxSize temp3 ;
39836 PyObject * obj0 = 0 ;
39837 PyObject * obj1 = 0 ;
39838 PyObject * obj2 = 0 ;
39839 char *kwnames[] = {
39840 (char *) "self",(char *) "item",(char *) "size", NULL
39841 };
39842
39843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = &temp3;
39849 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39850 }
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 Py_INCREF(Py_None); resultobj = Py_None;
39859 return resultobj;
39860 fail:
39861 return NULL;
39862 }
39863
39864
39865 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj;
39867 wxSizer *arg1 = (wxSizer *) 0 ;
39868 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39869 wxSizerItem *result;
39870 PyObject * obj0 = 0 ;
39871 PyObject * obj1 = 0 ;
39872 char *kwnames[] = {
39873 (char *) "self",(char *) "item", NULL
39874 };
39875
39876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39878 if (SWIG_arg_fail(1)) SWIG_fail;
39879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39880 if (SWIG_arg_fail(2)) SWIG_fail;
39881 {
39882 PyThreadState* __tstate = wxPyBeginAllowThreads();
39883 result = (wxSizerItem *)(arg1)->Add(arg2);
39884
39885 wxPyEndAllowThreads(__tstate);
39886 if (PyErr_Occurred()) SWIG_fail;
39887 }
39888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39889 return resultobj;
39890 fail:
39891 return NULL;
39892 }
39893
39894
39895 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39896 PyObject *resultobj;
39897 wxSizer *arg1 = (wxSizer *) 0 ;
39898 size_t arg2 ;
39899 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39900 wxSizerItem *result;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 PyObject * obj2 = 0 ;
39904 char *kwnames[] = {
39905 (char *) "self",(char *) "index",(char *) "item", NULL
39906 };
39907
39908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39910 if (SWIG_arg_fail(1)) SWIG_fail;
39911 {
39912 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39913 if (SWIG_arg_fail(2)) SWIG_fail;
39914 }
39915 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39916 if (SWIG_arg_fail(3)) SWIG_fail;
39917 {
39918 PyThreadState* __tstate = wxPyBeginAllowThreads();
39919 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39920
39921 wxPyEndAllowThreads(__tstate);
39922 if (PyErr_Occurred()) SWIG_fail;
39923 }
39924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39925 return resultobj;
39926 fail:
39927 return NULL;
39928 }
39929
39930
39931 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39932 PyObject *resultobj;
39933 wxSizer *arg1 = (wxSizer *) 0 ;
39934 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39935 wxSizerItem *result;
39936 PyObject * obj0 = 0 ;
39937 PyObject * obj1 = 0 ;
39938 char *kwnames[] = {
39939 (char *) "self",(char *) "item", NULL
39940 };
39941
39942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39944 if (SWIG_arg_fail(1)) SWIG_fail;
39945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39946 if (SWIG_arg_fail(2)) SWIG_fail;
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39950
39951 wxPyEndAllowThreads(__tstate);
39952 if (PyErr_Occurred()) SWIG_fail;
39953 }
39954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39955 return resultobj;
39956 fail:
39957 return NULL;
39958 }
39959
39960
39961 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39962 PyObject *resultobj;
39963 wxSizer *arg1 = (wxSizer *) 0 ;
39964 int arg2 ;
39965 int arg3 ;
39966 int arg4 ;
39967 int arg5 ;
39968 PyObject * obj0 = 0 ;
39969 PyObject * obj1 = 0 ;
39970 PyObject * obj2 = 0 ;
39971 PyObject * obj3 = 0 ;
39972 PyObject * obj4 = 0 ;
39973 char *kwnames[] = {
39974 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39975 };
39976
39977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(1)) SWIG_fail;
39980 {
39981 arg2 = (int)(SWIG_As_int(obj1));
39982 if (SWIG_arg_fail(2)) SWIG_fail;
39983 }
39984 {
39985 arg3 = (int)(SWIG_As_int(obj2));
39986 if (SWIG_arg_fail(3)) SWIG_fail;
39987 }
39988 {
39989 arg4 = (int)(SWIG_As_int(obj3));
39990 if (SWIG_arg_fail(4)) SWIG_fail;
39991 }
39992 {
39993 arg5 = (int)(SWIG_As_int(obj4));
39994 if (SWIG_arg_fail(5)) SWIG_fail;
39995 }
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39999
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 Py_INCREF(Py_None); resultobj = Py_None;
40004 return resultobj;
40005 fail:
40006 return NULL;
40007 }
40008
40009
40010 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40011 PyObject *resultobj;
40012 wxSizer *arg1 = (wxSizer *) 0 ;
40013 wxSize *arg2 = 0 ;
40014 wxSize temp2 ;
40015 PyObject * obj0 = 0 ;
40016 PyObject * obj1 = 0 ;
40017 char *kwnames[] = {
40018 (char *) "self",(char *) "size", NULL
40019 };
40020
40021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40023 if (SWIG_arg_fail(1)) SWIG_fail;
40024 {
40025 arg2 = &temp2;
40026 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40027 }
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 (arg1)->SetMinSize((wxSize const &)*arg2);
40031
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 Py_INCREF(Py_None); resultobj = Py_None;
40036 return resultobj;
40037 fail:
40038 return NULL;
40039 }
40040
40041
40042 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj;
40044 wxSizer *arg1 = (wxSizer *) 0 ;
40045 wxSize result;
40046 PyObject * obj0 = 0 ;
40047 char *kwnames[] = {
40048 (char *) "self", NULL
40049 };
40050
40051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40053 if (SWIG_arg_fail(1)) SWIG_fail;
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 result = (arg1)->GetSize();
40057
40058 wxPyEndAllowThreads(__tstate);
40059 if (PyErr_Occurred()) SWIG_fail;
40060 }
40061 {
40062 wxSize * resultptr;
40063 resultptr = new wxSize((wxSize &)(result));
40064 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40065 }
40066 return resultobj;
40067 fail:
40068 return NULL;
40069 }
40070
40071
40072 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40073 PyObject *resultobj;
40074 wxSizer *arg1 = (wxSizer *) 0 ;
40075 wxPoint result;
40076 PyObject * obj0 = 0 ;
40077 char *kwnames[] = {
40078 (char *) "self", NULL
40079 };
40080
40081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40083 if (SWIG_arg_fail(1)) SWIG_fail;
40084 {
40085 PyThreadState* __tstate = wxPyBeginAllowThreads();
40086 result = (arg1)->GetPosition();
40087
40088 wxPyEndAllowThreads(__tstate);
40089 if (PyErr_Occurred()) SWIG_fail;
40090 }
40091 {
40092 wxPoint * resultptr;
40093 resultptr = new wxPoint((wxPoint &)(result));
40094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40095 }
40096 return resultobj;
40097 fail:
40098 return NULL;
40099 }
40100
40101
40102 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40103 PyObject *resultobj;
40104 wxSizer *arg1 = (wxSizer *) 0 ;
40105 wxSize result;
40106 PyObject * obj0 = 0 ;
40107 char *kwnames[] = {
40108 (char *) "self", NULL
40109 };
40110
40111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40113 if (SWIG_arg_fail(1)) SWIG_fail;
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 result = (arg1)->GetMinSize();
40117
40118 wxPyEndAllowThreads(__tstate);
40119 if (PyErr_Occurred()) SWIG_fail;
40120 }
40121 {
40122 wxSize * resultptr;
40123 resultptr = new wxSize((wxSize &)(result));
40124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40125 }
40126 return resultobj;
40127 fail:
40128 return NULL;
40129 }
40130
40131
40132 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40133 PyObject *resultobj;
40134 wxSizer *arg1 = (wxSizer *) 0 ;
40135 PyObject * obj0 = 0 ;
40136 char *kwnames[] = {
40137 (char *) "self", NULL
40138 };
40139
40140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40142 if (SWIG_arg_fail(1)) SWIG_fail;
40143 {
40144 PyThreadState* __tstate = wxPyBeginAllowThreads();
40145 (arg1)->RecalcSizes();
40146
40147 wxPyEndAllowThreads(__tstate);
40148 if (PyErr_Occurred()) SWIG_fail;
40149 }
40150 Py_INCREF(Py_None); resultobj = Py_None;
40151 return resultobj;
40152 fail:
40153 return NULL;
40154 }
40155
40156
40157 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40158 PyObject *resultobj;
40159 wxSizer *arg1 = (wxSizer *) 0 ;
40160 wxSize result;
40161 PyObject * obj0 = 0 ;
40162 char *kwnames[] = {
40163 (char *) "self", NULL
40164 };
40165
40166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40168 if (SWIG_arg_fail(1)) SWIG_fail;
40169 {
40170 PyThreadState* __tstate = wxPyBeginAllowThreads();
40171 result = (arg1)->CalcMin();
40172
40173 wxPyEndAllowThreads(__tstate);
40174 if (PyErr_Occurred()) SWIG_fail;
40175 }
40176 {
40177 wxSize * resultptr;
40178 resultptr = new wxSize((wxSize &)(result));
40179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40180 }
40181 return resultobj;
40182 fail:
40183 return NULL;
40184 }
40185
40186
40187 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40188 PyObject *resultobj;
40189 wxSizer *arg1 = (wxSizer *) 0 ;
40190 PyObject * obj0 = 0 ;
40191 char *kwnames[] = {
40192 (char *) "self", NULL
40193 };
40194
40195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40197 if (SWIG_arg_fail(1)) SWIG_fail;
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 (arg1)->Layout();
40201
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 Py_INCREF(Py_None); resultobj = Py_None;
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj;
40214 wxSizer *arg1 = (wxSizer *) 0 ;
40215 wxWindow *arg2 = (wxWindow *) 0 ;
40216 wxSize result;
40217 PyObject * obj0 = 0 ;
40218 PyObject * obj1 = 0 ;
40219 char *kwnames[] = {
40220 (char *) "self",(char *) "window", NULL
40221 };
40222
40223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40225 if (SWIG_arg_fail(1)) SWIG_fail;
40226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40227 if (SWIG_arg_fail(2)) SWIG_fail;
40228 {
40229 PyThreadState* __tstate = wxPyBeginAllowThreads();
40230 result = (arg1)->Fit(arg2);
40231
40232 wxPyEndAllowThreads(__tstate);
40233 if (PyErr_Occurred()) SWIG_fail;
40234 }
40235 {
40236 wxSize * resultptr;
40237 resultptr = new wxSize((wxSize &)(result));
40238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40239 }
40240 return resultobj;
40241 fail:
40242 return NULL;
40243 }
40244
40245
40246 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40247 PyObject *resultobj;
40248 wxSizer *arg1 = (wxSizer *) 0 ;
40249 wxWindow *arg2 = (wxWindow *) 0 ;
40250 PyObject * obj0 = 0 ;
40251 PyObject * obj1 = 0 ;
40252 char *kwnames[] = {
40253 (char *) "self",(char *) "window", NULL
40254 };
40255
40256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40258 if (SWIG_arg_fail(1)) SWIG_fail;
40259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(2)) SWIG_fail;
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->FitInside(arg2);
40264
40265 wxPyEndAllowThreads(__tstate);
40266 if (PyErr_Occurred()) SWIG_fail;
40267 }
40268 Py_INCREF(Py_None); resultobj = Py_None;
40269 return resultobj;
40270 fail:
40271 return NULL;
40272 }
40273
40274
40275 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj;
40277 wxSizer *arg1 = (wxSizer *) 0 ;
40278 wxWindow *arg2 = (wxWindow *) 0 ;
40279 PyObject * obj0 = 0 ;
40280 PyObject * obj1 = 0 ;
40281 char *kwnames[] = {
40282 (char *) "self",(char *) "window", NULL
40283 };
40284
40285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40287 if (SWIG_arg_fail(1)) SWIG_fail;
40288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40289 if (SWIG_arg_fail(2)) SWIG_fail;
40290 {
40291 PyThreadState* __tstate = wxPyBeginAllowThreads();
40292 (arg1)->SetSizeHints(arg2);
40293
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 Py_INCREF(Py_None); resultobj = Py_None;
40298 return resultobj;
40299 fail:
40300 return NULL;
40301 }
40302
40303
40304 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40305 PyObject *resultobj;
40306 wxSizer *arg1 = (wxSizer *) 0 ;
40307 wxWindow *arg2 = (wxWindow *) 0 ;
40308 PyObject * obj0 = 0 ;
40309 PyObject * obj1 = 0 ;
40310 char *kwnames[] = {
40311 (char *) "self",(char *) "window", NULL
40312 };
40313
40314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40316 if (SWIG_arg_fail(1)) SWIG_fail;
40317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40318 if (SWIG_arg_fail(2)) SWIG_fail;
40319 {
40320 PyThreadState* __tstate = wxPyBeginAllowThreads();
40321 (arg1)->SetVirtualSizeHints(arg2);
40322
40323 wxPyEndAllowThreads(__tstate);
40324 if (PyErr_Occurred()) SWIG_fail;
40325 }
40326 Py_INCREF(Py_None); resultobj = Py_None;
40327 return resultobj;
40328 fail:
40329 return NULL;
40330 }
40331
40332
40333 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40334 PyObject *resultobj;
40335 wxSizer *arg1 = (wxSizer *) 0 ;
40336 bool arg2 = (bool) false ;
40337 PyObject * obj0 = 0 ;
40338 PyObject * obj1 = 0 ;
40339 char *kwnames[] = {
40340 (char *) "self",(char *) "deleteWindows", NULL
40341 };
40342
40343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40345 if (SWIG_arg_fail(1)) SWIG_fail;
40346 if (obj1) {
40347 {
40348 arg2 = (bool)(SWIG_As_bool(obj1));
40349 if (SWIG_arg_fail(2)) SWIG_fail;
40350 }
40351 }
40352 {
40353 PyThreadState* __tstate = wxPyBeginAllowThreads();
40354 (arg1)->Clear(arg2);
40355
40356 wxPyEndAllowThreads(__tstate);
40357 if (PyErr_Occurred()) SWIG_fail;
40358 }
40359 Py_INCREF(Py_None); resultobj = Py_None;
40360 return resultobj;
40361 fail:
40362 return NULL;
40363 }
40364
40365
40366 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40367 PyObject *resultobj;
40368 wxSizer *arg1 = (wxSizer *) 0 ;
40369 PyObject * obj0 = 0 ;
40370 char *kwnames[] = {
40371 (char *) "self", NULL
40372 };
40373
40374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) 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 {
40378 PyThreadState* __tstate = wxPyBeginAllowThreads();
40379 (arg1)->DeleteWindows();
40380
40381 wxPyEndAllowThreads(__tstate);
40382 if (PyErr_Occurred()) SWIG_fail;
40383 }
40384 Py_INCREF(Py_None); resultobj = Py_None;
40385 return resultobj;
40386 fail:
40387 return NULL;
40388 }
40389
40390
40391 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40392 PyObject *resultobj;
40393 wxSizer *arg1 = (wxSizer *) 0 ;
40394 PyObject *result;
40395 PyObject * obj0 = 0 ;
40396 char *kwnames[] = {
40397 (char *) "self", NULL
40398 };
40399
40400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40402 if (SWIG_arg_fail(1)) SWIG_fail;
40403 {
40404 PyThreadState* __tstate = wxPyBeginAllowThreads();
40405 result = (PyObject *)wxSizer_GetChildren(arg1);
40406
40407 wxPyEndAllowThreads(__tstate);
40408 if (PyErr_Occurred()) SWIG_fail;
40409 }
40410 resultobj = result;
40411 return resultobj;
40412 fail:
40413 return NULL;
40414 }
40415
40416
40417 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40418 PyObject *resultobj;
40419 wxSizer *arg1 = (wxSizer *) 0 ;
40420 PyObject *arg2 = (PyObject *) 0 ;
40421 bool arg3 = (bool) true ;
40422 bool arg4 = (bool) false ;
40423 bool result;
40424 PyObject * obj0 = 0 ;
40425 PyObject * obj1 = 0 ;
40426 PyObject * obj2 = 0 ;
40427 PyObject * obj3 = 0 ;
40428 char *kwnames[] = {
40429 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40430 };
40431
40432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40434 if (SWIG_arg_fail(1)) SWIG_fail;
40435 arg2 = obj1;
40436 if (obj2) {
40437 {
40438 arg3 = (bool)(SWIG_As_bool(obj2));
40439 if (SWIG_arg_fail(3)) SWIG_fail;
40440 }
40441 }
40442 if (obj3) {
40443 {
40444 arg4 = (bool)(SWIG_As_bool(obj3));
40445 if (SWIG_arg_fail(4)) SWIG_fail;
40446 }
40447 }
40448 {
40449 PyThreadState* __tstate = wxPyBeginAllowThreads();
40450 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40451
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 {
40456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40457 }
40458 return resultobj;
40459 fail:
40460 return NULL;
40461 }
40462
40463
40464 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40465 PyObject *resultobj;
40466 wxSizer *arg1 = (wxSizer *) 0 ;
40467 PyObject *arg2 = (PyObject *) 0 ;
40468 bool result;
40469 PyObject * obj0 = 0 ;
40470 PyObject * obj1 = 0 ;
40471 char *kwnames[] = {
40472 (char *) "self",(char *) "item", NULL
40473 };
40474
40475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40477 if (SWIG_arg_fail(1)) SWIG_fail;
40478 arg2 = obj1;
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = (bool)wxSizer_IsShown(arg1,arg2);
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_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40496 PyObject *resultobj;
40497 wxSizer *arg1 = (wxSizer *) 0 ;
40498 bool arg2 ;
40499 PyObject * obj0 = 0 ;
40500 PyObject * obj1 = 0 ;
40501 char *kwnames[] = {
40502 (char *) "self",(char *) "show", NULL
40503 };
40504
40505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40507 if (SWIG_arg_fail(1)) SWIG_fail;
40508 {
40509 arg2 = (bool)(SWIG_As_bool(obj1));
40510 if (SWIG_arg_fail(2)) SWIG_fail;
40511 }
40512 {
40513 PyThreadState* __tstate = wxPyBeginAllowThreads();
40514 (arg1)->ShowItems(arg2);
40515
40516 wxPyEndAllowThreads(__tstate);
40517 if (PyErr_Occurred()) SWIG_fail;
40518 }
40519 Py_INCREF(Py_None); resultobj = Py_None;
40520 return resultobj;
40521 fail:
40522 return NULL;
40523 }
40524
40525
40526 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40527 PyObject *obj;
40528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40529 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40530 Py_INCREF(obj);
40531 return Py_BuildValue((char *)"");
40532 }
40533 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj;
40535 wxPySizer *result;
40536 char *kwnames[] = {
40537 NULL
40538 };
40539
40540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40541 {
40542 PyThreadState* __tstate = wxPyBeginAllowThreads();
40543 result = (wxPySizer *)new wxPySizer();
40544
40545 wxPyEndAllowThreads(__tstate);
40546 if (PyErr_Occurred()) SWIG_fail;
40547 }
40548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40549 return resultobj;
40550 fail:
40551 return NULL;
40552 }
40553
40554
40555 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40556 PyObject *resultobj;
40557 wxPySizer *arg1 = (wxPySizer *) 0 ;
40558 PyObject *arg2 = (PyObject *) 0 ;
40559 PyObject *arg3 = (PyObject *) 0 ;
40560 PyObject * obj0 = 0 ;
40561 PyObject * obj1 = 0 ;
40562 PyObject * obj2 = 0 ;
40563 char *kwnames[] = {
40564 (char *) "self",(char *) "self",(char *) "_class", NULL
40565 };
40566
40567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40569 if (SWIG_arg_fail(1)) SWIG_fail;
40570 arg2 = obj1;
40571 arg3 = obj2;
40572 {
40573 PyThreadState* __tstate = wxPyBeginAllowThreads();
40574 (arg1)->_setCallbackInfo(arg2,arg3);
40575
40576 wxPyEndAllowThreads(__tstate);
40577 if (PyErr_Occurred()) SWIG_fail;
40578 }
40579 Py_INCREF(Py_None); resultobj = Py_None;
40580 return resultobj;
40581 fail:
40582 return NULL;
40583 }
40584
40585
40586 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40587 PyObject *obj;
40588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40589 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40590 Py_INCREF(obj);
40591 return Py_BuildValue((char *)"");
40592 }
40593 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40594 PyObject *resultobj;
40595 int arg1 = (int) wxHORIZONTAL ;
40596 wxBoxSizer *result;
40597 PyObject * obj0 = 0 ;
40598 char *kwnames[] = {
40599 (char *) "orient", NULL
40600 };
40601
40602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40603 if (obj0) {
40604 {
40605 arg1 = (int)(SWIG_As_int(obj0));
40606 if (SWIG_arg_fail(1)) SWIG_fail;
40607 }
40608 }
40609 {
40610 PyThreadState* __tstate = wxPyBeginAllowThreads();
40611 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40612
40613 wxPyEndAllowThreads(__tstate);
40614 if (PyErr_Occurred()) SWIG_fail;
40615 }
40616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40617 return resultobj;
40618 fail:
40619 return NULL;
40620 }
40621
40622
40623 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40624 PyObject *resultobj;
40625 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40626 int result;
40627 PyObject * obj0 = 0 ;
40628 char *kwnames[] = {
40629 (char *) "self", NULL
40630 };
40631
40632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40634 if (SWIG_arg_fail(1)) SWIG_fail;
40635 {
40636 PyThreadState* __tstate = wxPyBeginAllowThreads();
40637 result = (int)(arg1)->GetOrientation();
40638
40639 wxPyEndAllowThreads(__tstate);
40640 if (PyErr_Occurred()) SWIG_fail;
40641 }
40642 {
40643 resultobj = SWIG_From_int((int)(result));
40644 }
40645 return resultobj;
40646 fail:
40647 return NULL;
40648 }
40649
40650
40651 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40652 PyObject *resultobj;
40653 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40654 int arg2 ;
40655 PyObject * obj0 = 0 ;
40656 PyObject * obj1 = 0 ;
40657 char *kwnames[] = {
40658 (char *) "self",(char *) "orient", NULL
40659 };
40660
40661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40663 if (SWIG_arg_fail(1)) SWIG_fail;
40664 {
40665 arg2 = (int)(SWIG_As_int(obj1));
40666 if (SWIG_arg_fail(2)) SWIG_fail;
40667 }
40668 {
40669 PyThreadState* __tstate = wxPyBeginAllowThreads();
40670 (arg1)->SetOrientation(arg2);
40671
40672 wxPyEndAllowThreads(__tstate);
40673 if (PyErr_Occurred()) SWIG_fail;
40674 }
40675 Py_INCREF(Py_None); resultobj = Py_None;
40676 return resultobj;
40677 fail:
40678 return NULL;
40679 }
40680
40681
40682 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40683 PyObject *obj;
40684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40685 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40686 Py_INCREF(obj);
40687 return Py_BuildValue((char *)"");
40688 }
40689 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40690 PyObject *resultobj;
40691 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40692 int arg2 = (int) wxHORIZONTAL ;
40693 wxStaticBoxSizer *result;
40694 PyObject * obj0 = 0 ;
40695 PyObject * obj1 = 0 ;
40696 char *kwnames[] = {
40697 (char *) "box",(char *) "orient", NULL
40698 };
40699
40700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40702 if (SWIG_arg_fail(1)) SWIG_fail;
40703 if (obj1) {
40704 {
40705 arg2 = (int)(SWIG_As_int(obj1));
40706 if (SWIG_arg_fail(2)) SWIG_fail;
40707 }
40708 }
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40712
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40717 return resultobj;
40718 fail:
40719 return NULL;
40720 }
40721
40722
40723 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40724 PyObject *resultobj;
40725 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40726 wxStaticBox *result;
40727 PyObject * obj0 = 0 ;
40728 char *kwnames[] = {
40729 (char *) "self", NULL
40730 };
40731
40732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40734 if (SWIG_arg_fail(1)) SWIG_fail;
40735 {
40736 PyThreadState* __tstate = wxPyBeginAllowThreads();
40737 result = (wxStaticBox *)(arg1)->GetStaticBox();
40738
40739 wxPyEndAllowThreads(__tstate);
40740 if (PyErr_Occurred()) SWIG_fail;
40741 }
40742 {
40743 resultobj = wxPyMake_wxObject(result, 0);
40744 }
40745 return resultobj;
40746 fail:
40747 return NULL;
40748 }
40749
40750
40751 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40752 PyObject *obj;
40753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40754 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40755 Py_INCREF(obj);
40756 return Py_BuildValue((char *)"");
40757 }
40758 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj;
40760 int arg1 = (int) 1 ;
40761 int arg2 = (int) 0 ;
40762 int arg3 = (int) 0 ;
40763 int arg4 = (int) 0 ;
40764 wxGridSizer *result;
40765 PyObject * obj0 = 0 ;
40766 PyObject * obj1 = 0 ;
40767 PyObject * obj2 = 0 ;
40768 PyObject * obj3 = 0 ;
40769 char *kwnames[] = {
40770 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40771 };
40772
40773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40774 if (obj0) {
40775 {
40776 arg1 = (int)(SWIG_As_int(obj0));
40777 if (SWIG_arg_fail(1)) SWIG_fail;
40778 }
40779 }
40780 if (obj1) {
40781 {
40782 arg2 = (int)(SWIG_As_int(obj1));
40783 if (SWIG_arg_fail(2)) SWIG_fail;
40784 }
40785 }
40786 if (obj2) {
40787 {
40788 arg3 = (int)(SWIG_As_int(obj2));
40789 if (SWIG_arg_fail(3)) SWIG_fail;
40790 }
40791 }
40792 if (obj3) {
40793 {
40794 arg4 = (int)(SWIG_As_int(obj3));
40795 if (SWIG_arg_fail(4)) SWIG_fail;
40796 }
40797 }
40798 {
40799 PyThreadState* __tstate = wxPyBeginAllowThreads();
40800 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40801
40802 wxPyEndAllowThreads(__tstate);
40803 if (PyErr_Occurred()) SWIG_fail;
40804 }
40805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40806 return resultobj;
40807 fail:
40808 return NULL;
40809 }
40810
40811
40812 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40813 PyObject *resultobj;
40814 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40815 int arg2 ;
40816 PyObject * obj0 = 0 ;
40817 PyObject * obj1 = 0 ;
40818 char *kwnames[] = {
40819 (char *) "self",(char *) "cols", NULL
40820 };
40821
40822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40824 if (SWIG_arg_fail(1)) SWIG_fail;
40825 {
40826 arg2 = (int)(SWIG_As_int(obj1));
40827 if (SWIG_arg_fail(2)) SWIG_fail;
40828 }
40829 {
40830 PyThreadState* __tstate = wxPyBeginAllowThreads();
40831 (arg1)->SetCols(arg2);
40832
40833 wxPyEndAllowThreads(__tstate);
40834 if (PyErr_Occurred()) SWIG_fail;
40835 }
40836 Py_INCREF(Py_None); resultobj = Py_None;
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 static PyObject *_wrap_GridSizer_SetRows(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 *) "rows", NULL
40851 };
40852
40853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",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)->SetRows(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_SetVGap(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 *) "gap", NULL
40882 };
40883
40884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",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)->SetVGap(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_SetHGap(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_SetHGap",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)->SetHGap(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_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40937 PyObject *resultobj;
40938 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40939 int result;
40940 PyObject * obj0 = 0 ;
40941 char *kwnames[] = {
40942 (char *) "self", NULL
40943 };
40944
40945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40947 if (SWIG_arg_fail(1)) SWIG_fail;
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 result = (int)(arg1)->GetCols();
40951
40952 wxPyEndAllowThreads(__tstate);
40953 if (PyErr_Occurred()) SWIG_fail;
40954 }
40955 {
40956 resultobj = SWIG_From_int((int)(result));
40957 }
40958 return resultobj;
40959 fail:
40960 return NULL;
40961 }
40962
40963
40964 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40965 PyObject *resultobj;
40966 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40967 int result;
40968 PyObject * obj0 = 0 ;
40969 char *kwnames[] = {
40970 (char *) "self", NULL
40971 };
40972
40973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40975 if (SWIG_arg_fail(1)) SWIG_fail;
40976 {
40977 PyThreadState* __tstate = wxPyBeginAllowThreads();
40978 result = (int)(arg1)->GetRows();
40979
40980 wxPyEndAllowThreads(__tstate);
40981 if (PyErr_Occurred()) SWIG_fail;
40982 }
40983 {
40984 resultobj = SWIG_From_int((int)(result));
40985 }
40986 return resultobj;
40987 fail:
40988 return NULL;
40989 }
40990
40991
40992 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40993 PyObject *resultobj;
40994 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40995 int result;
40996 PyObject * obj0 = 0 ;
40997 char *kwnames[] = {
40998 (char *) "self", NULL
40999 };
41000
41001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41003 if (SWIG_arg_fail(1)) SWIG_fail;
41004 {
41005 PyThreadState* __tstate = wxPyBeginAllowThreads();
41006 result = (int)(arg1)->GetVGap();
41007
41008 wxPyEndAllowThreads(__tstate);
41009 if (PyErr_Occurred()) SWIG_fail;
41010 }
41011 {
41012 resultobj = SWIG_From_int((int)(result));
41013 }
41014 return resultobj;
41015 fail:
41016 return NULL;
41017 }
41018
41019
41020 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41021 PyObject *resultobj;
41022 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41023 int result;
41024 PyObject * obj0 = 0 ;
41025 char *kwnames[] = {
41026 (char *) "self", NULL
41027 };
41028
41029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41031 if (SWIG_arg_fail(1)) SWIG_fail;
41032 {
41033 PyThreadState* __tstate = wxPyBeginAllowThreads();
41034 result = (int)(arg1)->GetHGap();
41035
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 {
41040 resultobj = SWIG_From_int((int)(result));
41041 }
41042 return resultobj;
41043 fail:
41044 return NULL;
41045 }
41046
41047
41048 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41049 PyObject *obj;
41050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41051 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41052 Py_INCREF(obj);
41053 return Py_BuildValue((char *)"");
41054 }
41055 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj;
41057 int arg1 = (int) 1 ;
41058 int arg2 = (int) 0 ;
41059 int arg3 = (int) 0 ;
41060 int arg4 = (int) 0 ;
41061 wxFlexGridSizer *result;
41062 PyObject * obj0 = 0 ;
41063 PyObject * obj1 = 0 ;
41064 PyObject * obj2 = 0 ;
41065 PyObject * obj3 = 0 ;
41066 char *kwnames[] = {
41067 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41068 };
41069
41070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41071 if (obj0) {
41072 {
41073 arg1 = (int)(SWIG_As_int(obj0));
41074 if (SWIG_arg_fail(1)) SWIG_fail;
41075 }
41076 }
41077 if (obj1) {
41078 {
41079 arg2 = (int)(SWIG_As_int(obj1));
41080 if (SWIG_arg_fail(2)) SWIG_fail;
41081 }
41082 }
41083 if (obj2) {
41084 {
41085 arg3 = (int)(SWIG_As_int(obj2));
41086 if (SWIG_arg_fail(3)) SWIG_fail;
41087 }
41088 }
41089 if (obj3) {
41090 {
41091 arg4 = (int)(SWIG_As_int(obj3));
41092 if (SWIG_arg_fail(4)) SWIG_fail;
41093 }
41094 }
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41098
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41103 return resultobj;
41104 fail:
41105 return NULL;
41106 }
41107
41108
41109 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41110 PyObject *resultobj;
41111 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41112 size_t arg2 ;
41113 int arg3 = (int) 0 ;
41114 PyObject * obj0 = 0 ;
41115 PyObject * obj1 = 0 ;
41116 PyObject * obj2 = 0 ;
41117 char *kwnames[] = {
41118 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41119 };
41120
41121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41123 if (SWIG_arg_fail(1)) SWIG_fail;
41124 {
41125 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41126 if (SWIG_arg_fail(2)) SWIG_fail;
41127 }
41128 if (obj2) {
41129 {
41130 arg3 = (int)(SWIG_As_int(obj2));
41131 if (SWIG_arg_fail(3)) SWIG_fail;
41132 }
41133 }
41134 {
41135 PyThreadState* __tstate = wxPyBeginAllowThreads();
41136 (arg1)->AddGrowableRow(arg2,arg3);
41137
41138 wxPyEndAllowThreads(__tstate);
41139 if (PyErr_Occurred()) SWIG_fail;
41140 }
41141 Py_INCREF(Py_None); resultobj = Py_None;
41142 return resultobj;
41143 fail:
41144 return NULL;
41145 }
41146
41147
41148 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41149 PyObject *resultobj;
41150 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41151 size_t arg2 ;
41152 PyObject * obj0 = 0 ;
41153 PyObject * obj1 = 0 ;
41154 char *kwnames[] = {
41155 (char *) "self",(char *) "idx", NULL
41156 };
41157
41158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41160 if (SWIG_arg_fail(1)) SWIG_fail;
41161 {
41162 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41163 if (SWIG_arg_fail(2)) SWIG_fail;
41164 }
41165 {
41166 PyThreadState* __tstate = wxPyBeginAllowThreads();
41167 (arg1)->RemoveGrowableRow(arg2);
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_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41180 PyObject *resultobj;
41181 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41182 size_t arg2 ;
41183 int arg3 = (int) 0 ;
41184 PyObject * obj0 = 0 ;
41185 PyObject * obj1 = 0 ;
41186 PyObject * obj2 = 0 ;
41187 char *kwnames[] = {
41188 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41189 };
41190
41191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41193 if (SWIG_arg_fail(1)) SWIG_fail;
41194 {
41195 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41196 if (SWIG_arg_fail(2)) SWIG_fail;
41197 }
41198 if (obj2) {
41199 {
41200 arg3 = (int)(SWIG_As_int(obj2));
41201 if (SWIG_arg_fail(3)) SWIG_fail;
41202 }
41203 }
41204 {
41205 PyThreadState* __tstate = wxPyBeginAllowThreads();
41206 (arg1)->AddGrowableCol(arg2,arg3);
41207
41208 wxPyEndAllowThreads(__tstate);
41209 if (PyErr_Occurred()) SWIG_fail;
41210 }
41211 Py_INCREF(Py_None); resultobj = Py_None;
41212 return resultobj;
41213 fail:
41214 return NULL;
41215 }
41216
41217
41218 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41219 PyObject *resultobj;
41220 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41221 size_t arg2 ;
41222 PyObject * obj0 = 0 ;
41223 PyObject * obj1 = 0 ;
41224 char *kwnames[] = {
41225 (char *) "self",(char *) "idx", NULL
41226 };
41227
41228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41230 if (SWIG_arg_fail(1)) SWIG_fail;
41231 {
41232 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41233 if (SWIG_arg_fail(2)) SWIG_fail;
41234 }
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 (arg1)->RemoveGrowableCol(arg2);
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_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41250 PyObject *resultobj;
41251 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41252 int arg2 ;
41253 PyObject * obj0 = 0 ;
41254 PyObject * obj1 = 0 ;
41255 char *kwnames[] = {
41256 (char *) "self",(char *) "direction", NULL
41257 };
41258
41259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",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 = (int)(SWIG_As_int(obj1));
41264 if (SWIG_arg_fail(2)) SWIG_fail;
41265 }
41266 {
41267 PyThreadState* __tstate = wxPyBeginAllowThreads();
41268 (arg1)->SetFlexibleDirection(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_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41281 PyObject *resultobj;
41282 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41283 int result;
41284 PyObject * obj0 = 0 ;
41285 char *kwnames[] = {
41286 (char *) "self", NULL
41287 };
41288
41289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41291 if (SWIG_arg_fail(1)) SWIG_fail;
41292 {
41293 PyThreadState* __tstate = wxPyBeginAllowThreads();
41294 result = (int)(arg1)->GetFlexibleDirection();
41295
41296 wxPyEndAllowThreads(__tstate);
41297 if (PyErr_Occurred()) SWIG_fail;
41298 }
41299 {
41300 resultobj = SWIG_From_int((int)(result));
41301 }
41302 return resultobj;
41303 fail:
41304 return NULL;
41305 }
41306
41307
41308 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41309 PyObject *resultobj;
41310 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41311 wxFlexSizerGrowMode arg2 ;
41312 PyObject * obj0 = 0 ;
41313 PyObject * obj1 = 0 ;
41314 char *kwnames[] = {
41315 (char *) "self",(char *) "mode", NULL
41316 };
41317
41318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41320 if (SWIG_arg_fail(1)) SWIG_fail;
41321 {
41322 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41323 if (SWIG_arg_fail(2)) SWIG_fail;
41324 }
41325 {
41326 PyThreadState* __tstate = wxPyBeginAllowThreads();
41327 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41328
41329 wxPyEndAllowThreads(__tstate);
41330 if (PyErr_Occurred()) SWIG_fail;
41331 }
41332 Py_INCREF(Py_None); resultobj = Py_None;
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41340 PyObject *resultobj;
41341 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41342 wxFlexSizerGrowMode result;
41343 PyObject * obj0 = 0 ;
41344 char *kwnames[] = {
41345 (char *) "self", NULL
41346 };
41347
41348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41350 if (SWIG_arg_fail(1)) SWIG_fail;
41351 {
41352 PyThreadState* __tstate = wxPyBeginAllowThreads();
41353 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41354
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 resultobj = SWIG_From_int((result));
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj;
41367 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41368 wxArrayInt *result;
41369 PyObject * obj0 = 0 ;
41370 char *kwnames[] = {
41371 (char *) "self", NULL
41372 };
41373
41374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41376 if (SWIG_arg_fail(1)) SWIG_fail;
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 {
41380 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41381 result = (wxArrayInt *) &_result_ref;
41382 }
41383
41384 wxPyEndAllowThreads(__tstate);
41385 if (PyErr_Occurred()) SWIG_fail;
41386 }
41387 {
41388 resultobj = PyList_New(0);
41389 size_t idx;
41390 for (idx = 0; idx < result->GetCount(); idx += 1) {
41391 PyObject* val = PyInt_FromLong( result->Item(idx) );
41392 PyList_Append(resultobj, val);
41393 Py_DECREF(val);
41394 }
41395 }
41396 return resultobj;
41397 fail:
41398 return NULL;
41399 }
41400
41401
41402 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41403 PyObject *resultobj;
41404 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41405 wxArrayInt *result;
41406 PyObject * obj0 = 0 ;
41407 char *kwnames[] = {
41408 (char *) "self", NULL
41409 };
41410
41411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41413 if (SWIG_arg_fail(1)) SWIG_fail;
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 {
41417 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41418 result = (wxArrayInt *) &_result_ref;
41419 }
41420
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 {
41425 resultobj = PyList_New(0);
41426 size_t idx;
41427 for (idx = 0; idx < result->GetCount(); idx += 1) {
41428 PyObject* val = PyInt_FromLong( result->Item(idx) );
41429 PyList_Append(resultobj, val);
41430 Py_DECREF(val);
41431 }
41432 }
41433 return resultobj;
41434 fail:
41435 return NULL;
41436 }
41437
41438
41439 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41440 PyObject *obj;
41441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41442 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41443 Py_INCREF(obj);
41444 return Py_BuildValue((char *)"");
41445 }
41446 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41447 PyObject *resultobj;
41448 wxStdDialogButtonSizer *result;
41449 char *kwnames[] = {
41450 NULL
41451 };
41452
41453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41454 {
41455 PyThreadState* __tstate = wxPyBeginAllowThreads();
41456 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41457
41458 wxPyEndAllowThreads(__tstate);
41459 if (PyErr_Occurred()) SWIG_fail;
41460 }
41461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41462 return resultobj;
41463 fail:
41464 return NULL;
41465 }
41466
41467
41468 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41469 PyObject *resultobj;
41470 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41471 wxButton *arg2 = (wxButton *) 0 ;
41472 PyObject * obj0 = 0 ;
41473 PyObject * obj1 = 0 ;
41474 char *kwnames[] = {
41475 (char *) "self",(char *) "button", NULL
41476 };
41477
41478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41480 if (SWIG_arg_fail(1)) SWIG_fail;
41481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41482 if (SWIG_arg_fail(2)) SWIG_fail;
41483 {
41484 PyThreadState* __tstate = wxPyBeginAllowThreads();
41485 (arg1)->AddButton(arg2);
41486
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 Py_INCREF(Py_None); resultobj = Py_None;
41491 return resultobj;
41492 fail:
41493 return NULL;
41494 }
41495
41496
41497 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41498 PyObject *resultobj;
41499 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41500 PyObject * obj0 = 0 ;
41501 char *kwnames[] = {
41502 (char *) "self", NULL
41503 };
41504
41505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41507 if (SWIG_arg_fail(1)) SWIG_fail;
41508 {
41509 PyThreadState* __tstate = wxPyBeginAllowThreads();
41510 (arg1)->Realize();
41511
41512 wxPyEndAllowThreads(__tstate);
41513 if (PyErr_Occurred()) SWIG_fail;
41514 }
41515 Py_INCREF(Py_None); resultobj = Py_None;
41516 return resultobj;
41517 fail:
41518 return NULL;
41519 }
41520
41521
41522 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj;
41524 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41525 wxButton *arg2 = (wxButton *) 0 ;
41526 PyObject * obj0 = 0 ;
41527 PyObject * obj1 = 0 ;
41528 char *kwnames[] = {
41529 (char *) "self",(char *) "button", NULL
41530 };
41531
41532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41534 if (SWIG_arg_fail(1)) SWIG_fail;
41535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41536 if (SWIG_arg_fail(2)) SWIG_fail;
41537 {
41538 PyThreadState* __tstate = wxPyBeginAllowThreads();
41539 (arg1)->SetAffirmativeButton(arg2);
41540
41541 wxPyEndAllowThreads(__tstate);
41542 if (PyErr_Occurred()) SWIG_fail;
41543 }
41544 Py_INCREF(Py_None); resultobj = Py_None;
41545 return resultobj;
41546 fail:
41547 return NULL;
41548 }
41549
41550
41551 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41552 PyObject *resultobj;
41553 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41554 wxButton *arg2 = (wxButton *) 0 ;
41555 PyObject * obj0 = 0 ;
41556 PyObject * obj1 = 0 ;
41557 char *kwnames[] = {
41558 (char *) "self",(char *) "button", NULL
41559 };
41560
41561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41563 if (SWIG_arg_fail(1)) SWIG_fail;
41564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41565 if (SWIG_arg_fail(2)) SWIG_fail;
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 (arg1)->SetNegativeButton(arg2);
41569
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 Py_INCREF(Py_None); resultobj = Py_None;
41574 return resultobj;
41575 fail:
41576 return NULL;
41577 }
41578
41579
41580 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41581 PyObject *resultobj;
41582 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41583 wxButton *arg2 = (wxButton *) 0 ;
41584 PyObject * obj0 = 0 ;
41585 PyObject * obj1 = 0 ;
41586 char *kwnames[] = {
41587 (char *) "self",(char *) "button", NULL
41588 };
41589
41590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41592 if (SWIG_arg_fail(1)) SWIG_fail;
41593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(2)) SWIG_fail;
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 (arg1)->SetCancelButton(arg2);
41598
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 Py_INCREF(Py_None); resultobj = Py_None;
41603 return resultobj;
41604 fail:
41605 return NULL;
41606 }
41607
41608
41609 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41610 PyObject *resultobj;
41611 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41612 wxButton *result;
41613 PyObject * obj0 = 0 ;
41614 char *kwnames[] = {
41615 (char *) "self", NULL
41616 };
41617
41618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41620 if (SWIG_arg_fail(1)) SWIG_fail;
41621 {
41622 PyThreadState* __tstate = wxPyBeginAllowThreads();
41623 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41624
41625 wxPyEndAllowThreads(__tstate);
41626 if (PyErr_Occurred()) SWIG_fail;
41627 }
41628 {
41629 resultobj = wxPyMake_wxObject(result, 0);
41630 }
41631 return resultobj;
41632 fail:
41633 return NULL;
41634 }
41635
41636
41637 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41638 PyObject *resultobj;
41639 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41640 wxButton *result;
41641 PyObject * obj0 = 0 ;
41642 char *kwnames[] = {
41643 (char *) "self", NULL
41644 };
41645
41646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41648 if (SWIG_arg_fail(1)) SWIG_fail;
41649 {
41650 PyThreadState* __tstate = wxPyBeginAllowThreads();
41651 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41652
41653 wxPyEndAllowThreads(__tstate);
41654 if (PyErr_Occurred()) SWIG_fail;
41655 }
41656 {
41657 resultobj = wxPyMake_wxObject(result, 0);
41658 }
41659 return resultobj;
41660 fail:
41661 return NULL;
41662 }
41663
41664
41665 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41666 PyObject *resultobj;
41667 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41668 wxButton *result;
41669 PyObject * obj0 = 0 ;
41670 char *kwnames[] = {
41671 (char *) "self", NULL
41672 };
41673
41674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41676 if (SWIG_arg_fail(1)) SWIG_fail;
41677 {
41678 PyThreadState* __tstate = wxPyBeginAllowThreads();
41679 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41680
41681 wxPyEndAllowThreads(__tstate);
41682 if (PyErr_Occurred()) SWIG_fail;
41683 }
41684 {
41685 resultobj = wxPyMake_wxObject(result, 0);
41686 }
41687 return resultobj;
41688 fail:
41689 return NULL;
41690 }
41691
41692
41693 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41694 PyObject *resultobj;
41695 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41696 wxButton *result;
41697 PyObject * obj0 = 0 ;
41698 char *kwnames[] = {
41699 (char *) "self", NULL
41700 };
41701
41702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41704 if (SWIG_arg_fail(1)) SWIG_fail;
41705 {
41706 PyThreadState* __tstate = wxPyBeginAllowThreads();
41707 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41708
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 {
41713 resultobj = wxPyMake_wxObject(result, 0);
41714 }
41715 return resultobj;
41716 fail:
41717 return NULL;
41718 }
41719
41720
41721 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41722 PyObject *resultobj;
41723 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41724 wxButton *result;
41725 PyObject * obj0 = 0 ;
41726 char *kwnames[] = {
41727 (char *) "self", NULL
41728 };
41729
41730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41732 if (SWIG_arg_fail(1)) SWIG_fail;
41733 {
41734 PyThreadState* __tstate = wxPyBeginAllowThreads();
41735 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41736
41737 wxPyEndAllowThreads(__tstate);
41738 if (PyErr_Occurred()) SWIG_fail;
41739 }
41740 {
41741 resultobj = wxPyMake_wxObject(result, 0);
41742 }
41743 return resultobj;
41744 fail:
41745 return NULL;
41746 }
41747
41748
41749 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41750 PyObject *obj;
41751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41752 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41753 Py_INCREF(obj);
41754 return Py_BuildValue((char *)"");
41755 }
41756 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41757 PyObject *resultobj;
41758 int arg1 = (int) 0 ;
41759 int arg2 = (int) 0 ;
41760 wxGBPosition *result;
41761 PyObject * obj0 = 0 ;
41762 PyObject * obj1 = 0 ;
41763 char *kwnames[] = {
41764 (char *) "row",(char *) "col", NULL
41765 };
41766
41767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41768 if (obj0) {
41769 {
41770 arg1 = (int)(SWIG_As_int(obj0));
41771 if (SWIG_arg_fail(1)) SWIG_fail;
41772 }
41773 }
41774 if (obj1) {
41775 {
41776 arg2 = (int)(SWIG_As_int(obj1));
41777 if (SWIG_arg_fail(2)) SWIG_fail;
41778 }
41779 }
41780 {
41781 PyThreadState* __tstate = wxPyBeginAllowThreads();
41782 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41783
41784 wxPyEndAllowThreads(__tstate);
41785 if (PyErr_Occurred()) SWIG_fail;
41786 }
41787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41788 return resultobj;
41789 fail:
41790 return NULL;
41791 }
41792
41793
41794 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41795 PyObject *resultobj;
41796 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41797 int result;
41798 PyObject * obj0 = 0 ;
41799 char *kwnames[] = {
41800 (char *) "self", NULL
41801 };
41802
41803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41805 if (SWIG_arg_fail(1)) SWIG_fail;
41806 {
41807 PyThreadState* __tstate = wxPyBeginAllowThreads();
41808 result = (int)((wxGBPosition const *)arg1)->GetRow();
41809
41810 wxPyEndAllowThreads(__tstate);
41811 if (PyErr_Occurred()) SWIG_fail;
41812 }
41813 {
41814 resultobj = SWIG_From_int((int)(result));
41815 }
41816 return resultobj;
41817 fail:
41818 return NULL;
41819 }
41820
41821
41822 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41823 PyObject *resultobj;
41824 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41825 int result;
41826 PyObject * obj0 = 0 ;
41827 char *kwnames[] = {
41828 (char *) "self", NULL
41829 };
41830
41831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41833 if (SWIG_arg_fail(1)) SWIG_fail;
41834 {
41835 PyThreadState* __tstate = wxPyBeginAllowThreads();
41836 result = (int)((wxGBPosition const *)arg1)->GetCol();
41837
41838 wxPyEndAllowThreads(__tstate);
41839 if (PyErr_Occurred()) SWIG_fail;
41840 }
41841 {
41842 resultobj = SWIG_From_int((int)(result));
41843 }
41844 return resultobj;
41845 fail:
41846 return NULL;
41847 }
41848
41849
41850 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41851 PyObject *resultobj;
41852 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41853 int arg2 ;
41854 PyObject * obj0 = 0 ;
41855 PyObject * obj1 = 0 ;
41856 char *kwnames[] = {
41857 (char *) "self",(char *) "row", NULL
41858 };
41859
41860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41862 if (SWIG_arg_fail(1)) SWIG_fail;
41863 {
41864 arg2 = (int)(SWIG_As_int(obj1));
41865 if (SWIG_arg_fail(2)) SWIG_fail;
41866 }
41867 {
41868 PyThreadState* __tstate = wxPyBeginAllowThreads();
41869 (arg1)->SetRow(arg2);
41870
41871 wxPyEndAllowThreads(__tstate);
41872 if (PyErr_Occurred()) SWIG_fail;
41873 }
41874 Py_INCREF(Py_None); resultobj = Py_None;
41875 return resultobj;
41876 fail:
41877 return NULL;
41878 }
41879
41880
41881 static PyObject *_wrap_GBPosition_SetCol(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 *) "col", NULL
41889 };
41890
41891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",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)->SetCol(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___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41913 PyObject *resultobj;
41914 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41915 wxGBPosition *arg2 = 0 ;
41916 bool result;
41917 wxGBPosition temp2 ;
41918 PyObject * obj0 = 0 ;
41919 PyObject * obj1 = 0 ;
41920 char *kwnames[] = {
41921 (char *) "self",(char *) "other", NULL
41922 };
41923
41924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41926 if (SWIG_arg_fail(1)) SWIG_fail;
41927 {
41928 arg2 = &temp2;
41929 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41930 }
41931 {
41932 PyThreadState* __tstate = wxPyBeginAllowThreads();
41933 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41934
41935 wxPyEndAllowThreads(__tstate);
41936 if (PyErr_Occurred()) SWIG_fail;
41937 }
41938 {
41939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41940 }
41941 return resultobj;
41942 fail:
41943 return NULL;
41944 }
41945
41946
41947 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41948 PyObject *resultobj;
41949 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41950 wxGBPosition *arg2 = 0 ;
41951 bool result;
41952 wxGBPosition temp2 ;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 char *kwnames[] = {
41956 (char *) "self",(char *) "other", NULL
41957 };
41958
41959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41961 if (SWIG_arg_fail(1)) SWIG_fail;
41962 {
41963 arg2 = &temp2;
41964 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41965 }
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41969
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41975 }
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj;
41984 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41985 int arg2 = (int) 0 ;
41986 int arg3 = (int) 0 ;
41987 PyObject * obj0 = 0 ;
41988 PyObject * obj1 = 0 ;
41989 PyObject * obj2 = 0 ;
41990 char *kwnames[] = {
41991 (char *) "self",(char *) "row",(char *) "col", NULL
41992 };
41993
41994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41996 if (SWIG_arg_fail(1)) SWIG_fail;
41997 if (obj1) {
41998 {
41999 arg2 = (int)(SWIG_As_int(obj1));
42000 if (SWIG_arg_fail(2)) SWIG_fail;
42001 }
42002 }
42003 if (obj2) {
42004 {
42005 arg3 = (int)(SWIG_As_int(obj2));
42006 if (SWIG_arg_fail(3)) SWIG_fail;
42007 }
42008 }
42009 {
42010 PyThreadState* __tstate = wxPyBeginAllowThreads();
42011 wxGBPosition_Set(arg1,arg2,arg3);
42012
42013 wxPyEndAllowThreads(__tstate);
42014 if (PyErr_Occurred()) SWIG_fail;
42015 }
42016 Py_INCREF(Py_None); resultobj = Py_None;
42017 return resultobj;
42018 fail:
42019 return NULL;
42020 }
42021
42022
42023 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42024 PyObject *resultobj;
42025 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42026 PyObject *result;
42027 PyObject * obj0 = 0 ;
42028 char *kwnames[] = {
42029 (char *) "self", NULL
42030 };
42031
42032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42034 if (SWIG_arg_fail(1)) SWIG_fail;
42035 {
42036 PyThreadState* __tstate = wxPyBeginAllowThreads();
42037 result = (PyObject *)wxGBPosition_Get(arg1);
42038
42039 wxPyEndAllowThreads(__tstate);
42040 if (PyErr_Occurred()) SWIG_fail;
42041 }
42042 resultobj = result;
42043 return resultobj;
42044 fail:
42045 return NULL;
42046 }
42047
42048
42049 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42050 PyObject *obj;
42051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42052 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42053 Py_INCREF(obj);
42054 return Py_BuildValue((char *)"");
42055 }
42056 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42057 PyObject *resultobj;
42058 int arg1 = (int) 1 ;
42059 int arg2 = (int) 1 ;
42060 wxGBSpan *result;
42061 PyObject * obj0 = 0 ;
42062 PyObject * obj1 = 0 ;
42063 char *kwnames[] = {
42064 (char *) "rowspan",(char *) "colspan", NULL
42065 };
42066
42067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42068 if (obj0) {
42069 {
42070 arg1 = (int)(SWIG_As_int(obj0));
42071 if (SWIG_arg_fail(1)) SWIG_fail;
42072 }
42073 }
42074 if (obj1) {
42075 {
42076 arg2 = (int)(SWIG_As_int(obj1));
42077 if (SWIG_arg_fail(2)) SWIG_fail;
42078 }
42079 }
42080 {
42081 PyThreadState* __tstate = wxPyBeginAllowThreads();
42082 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42083
42084 wxPyEndAllowThreads(__tstate);
42085 if (PyErr_Occurred()) SWIG_fail;
42086 }
42087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42088 return resultobj;
42089 fail:
42090 return NULL;
42091 }
42092
42093
42094 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42095 PyObject *resultobj;
42096 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42097 int result;
42098 PyObject * obj0 = 0 ;
42099 char *kwnames[] = {
42100 (char *) "self", NULL
42101 };
42102
42103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42105 if (SWIG_arg_fail(1)) SWIG_fail;
42106 {
42107 PyThreadState* __tstate = wxPyBeginAllowThreads();
42108 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42109
42110 wxPyEndAllowThreads(__tstate);
42111 if (PyErr_Occurred()) SWIG_fail;
42112 }
42113 {
42114 resultobj = SWIG_From_int((int)(result));
42115 }
42116 return resultobj;
42117 fail:
42118 return NULL;
42119 }
42120
42121
42122 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42123 PyObject *resultobj;
42124 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42125 int result;
42126 PyObject * obj0 = 0 ;
42127 char *kwnames[] = {
42128 (char *) "self", NULL
42129 };
42130
42131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42133 if (SWIG_arg_fail(1)) SWIG_fail;
42134 {
42135 PyThreadState* __tstate = wxPyBeginAllowThreads();
42136 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42137
42138 wxPyEndAllowThreads(__tstate);
42139 if (PyErr_Occurred()) SWIG_fail;
42140 }
42141 {
42142 resultobj = SWIG_From_int((int)(result));
42143 }
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42151 PyObject *resultobj;
42152 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42153 int arg2 ;
42154 PyObject * obj0 = 0 ;
42155 PyObject * obj1 = 0 ;
42156 char *kwnames[] = {
42157 (char *) "self",(char *) "rowspan", NULL
42158 };
42159
42160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42162 if (SWIG_arg_fail(1)) SWIG_fail;
42163 {
42164 arg2 = (int)(SWIG_As_int(obj1));
42165 if (SWIG_arg_fail(2)) SWIG_fail;
42166 }
42167 {
42168 PyThreadState* __tstate = wxPyBeginAllowThreads();
42169 (arg1)->SetRowspan(arg2);
42170
42171 wxPyEndAllowThreads(__tstate);
42172 if (PyErr_Occurred()) SWIG_fail;
42173 }
42174 Py_INCREF(Py_None); resultobj = Py_None;
42175 return resultobj;
42176 fail:
42177 return NULL;
42178 }
42179
42180
42181 static PyObject *_wrap_GBSpan_SetColspan(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 *) "colspan", NULL
42189 };
42190
42191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",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)->SetColspan(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___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42213 PyObject *resultobj;
42214 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42215 wxGBSpan *arg2 = 0 ;
42216 bool result;
42217 wxGBSpan temp2 ;
42218 PyObject * obj0 = 0 ;
42219 PyObject * obj1 = 0 ;
42220 char *kwnames[] = {
42221 (char *) "self",(char *) "other", NULL
42222 };
42223
42224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42226 if (SWIG_arg_fail(1)) SWIG_fail;
42227 {
42228 arg2 = &temp2;
42229 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42230 }
42231 {
42232 PyThreadState* __tstate = wxPyBeginAllowThreads();
42233 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42234
42235 wxPyEndAllowThreads(__tstate);
42236 if (PyErr_Occurred()) SWIG_fail;
42237 }
42238 {
42239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42240 }
42241 return resultobj;
42242 fail:
42243 return NULL;
42244 }
42245
42246
42247 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42248 PyObject *resultobj;
42249 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42250 wxGBSpan *arg2 = 0 ;
42251 bool result;
42252 wxGBSpan temp2 ;
42253 PyObject * obj0 = 0 ;
42254 PyObject * obj1 = 0 ;
42255 char *kwnames[] = {
42256 (char *) "self",(char *) "other", NULL
42257 };
42258
42259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42261 if (SWIG_arg_fail(1)) SWIG_fail;
42262 {
42263 arg2 = &temp2;
42264 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42265 }
42266 {
42267 PyThreadState* __tstate = wxPyBeginAllowThreads();
42268 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42269
42270 wxPyEndAllowThreads(__tstate);
42271 if (PyErr_Occurred()) SWIG_fail;
42272 }
42273 {
42274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42275 }
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj;
42284 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42285 int arg2 = (int) 1 ;
42286 int arg3 = (int) 1 ;
42287 PyObject * obj0 = 0 ;
42288 PyObject * obj1 = 0 ;
42289 PyObject * obj2 = 0 ;
42290 char *kwnames[] = {
42291 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42292 };
42293
42294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42296 if (SWIG_arg_fail(1)) SWIG_fail;
42297 if (obj1) {
42298 {
42299 arg2 = (int)(SWIG_As_int(obj1));
42300 if (SWIG_arg_fail(2)) SWIG_fail;
42301 }
42302 }
42303 if (obj2) {
42304 {
42305 arg3 = (int)(SWIG_As_int(obj2));
42306 if (SWIG_arg_fail(3)) SWIG_fail;
42307 }
42308 }
42309 {
42310 PyThreadState* __tstate = wxPyBeginAllowThreads();
42311 wxGBSpan_Set(arg1,arg2,arg3);
42312
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 Py_INCREF(Py_None); resultobj = Py_None;
42317 return resultobj;
42318 fail:
42319 return NULL;
42320 }
42321
42322
42323 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42324 PyObject *resultobj;
42325 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42326 PyObject *result;
42327 PyObject * obj0 = 0 ;
42328 char *kwnames[] = {
42329 (char *) "self", NULL
42330 };
42331
42332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42334 if (SWIG_arg_fail(1)) SWIG_fail;
42335 {
42336 PyThreadState* __tstate = wxPyBeginAllowThreads();
42337 result = (PyObject *)wxGBSpan_Get(arg1);
42338
42339 wxPyEndAllowThreads(__tstate);
42340 if (PyErr_Occurred()) SWIG_fail;
42341 }
42342 resultobj = result;
42343 return resultobj;
42344 fail:
42345 return NULL;
42346 }
42347
42348
42349 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42350 PyObject *obj;
42351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42352 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42353 Py_INCREF(obj);
42354 return Py_BuildValue((char *)"");
42355 }
42356 static int _wrap_DefaultSpan_set(PyObject *) {
42357 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42358 return 1;
42359 }
42360
42361
42362 static PyObject *_wrap_DefaultSpan_get(void) {
42363 PyObject *pyobj;
42364
42365 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42366 return pyobj;
42367 }
42368
42369
42370 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42371 PyObject *resultobj;
42372 wxGBSizerItem *result;
42373 char *kwnames[] = {
42374 NULL
42375 };
42376
42377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 result = (wxGBSizerItem *)new wxGBSizerItem();
42381
42382 wxPyEndAllowThreads(__tstate);
42383 if (PyErr_Occurred()) SWIG_fail;
42384 }
42385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42386 return resultobj;
42387 fail:
42388 return NULL;
42389 }
42390
42391
42392 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42393 PyObject *resultobj;
42394 wxWindow *arg1 = (wxWindow *) 0 ;
42395 wxGBPosition *arg2 = 0 ;
42396 wxGBSpan *arg3 = 0 ;
42397 int arg4 ;
42398 int arg5 ;
42399 PyObject *arg6 = (PyObject *) NULL ;
42400 wxGBSizerItem *result;
42401 wxGBPosition temp2 ;
42402 wxGBSpan temp3 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 PyObject * obj2 = 0 ;
42406 PyObject * obj3 = 0 ;
42407 PyObject * obj4 = 0 ;
42408 PyObject * obj5 = 0 ;
42409 char *kwnames[] = {
42410 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42411 };
42412
42413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42415 if (SWIG_arg_fail(1)) SWIG_fail;
42416 {
42417 arg2 = &temp2;
42418 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42419 }
42420 {
42421 arg3 = &temp3;
42422 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42423 }
42424 {
42425 arg4 = (int)(SWIG_As_int(obj3));
42426 if (SWIG_arg_fail(4)) SWIG_fail;
42427 }
42428 {
42429 arg5 = (int)(SWIG_As_int(obj4));
42430 if (SWIG_arg_fail(5)) SWIG_fail;
42431 }
42432 if (obj5) {
42433 arg6 = obj5;
42434 }
42435 {
42436 PyThreadState* __tstate = wxPyBeginAllowThreads();
42437 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42438
42439 wxPyEndAllowThreads(__tstate);
42440 if (PyErr_Occurred()) SWIG_fail;
42441 }
42442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42443 return resultobj;
42444 fail:
42445 return NULL;
42446 }
42447
42448
42449 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42450 PyObject *resultobj;
42451 wxSizer *arg1 = (wxSizer *) 0 ;
42452 wxGBPosition *arg2 = 0 ;
42453 wxGBSpan *arg3 = 0 ;
42454 int arg4 ;
42455 int arg5 ;
42456 PyObject *arg6 = (PyObject *) NULL ;
42457 wxGBSizerItem *result;
42458 wxGBPosition temp2 ;
42459 wxGBSpan temp3 ;
42460 PyObject * obj0 = 0 ;
42461 PyObject * obj1 = 0 ;
42462 PyObject * obj2 = 0 ;
42463 PyObject * obj3 = 0 ;
42464 PyObject * obj4 = 0 ;
42465 PyObject * obj5 = 0 ;
42466 char *kwnames[] = {
42467 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42468 };
42469
42470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42472 if (SWIG_arg_fail(1)) SWIG_fail;
42473 {
42474 arg2 = &temp2;
42475 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42476 }
42477 {
42478 arg3 = &temp3;
42479 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42480 }
42481 {
42482 arg4 = (int)(SWIG_As_int(obj3));
42483 if (SWIG_arg_fail(4)) SWIG_fail;
42484 }
42485 {
42486 arg5 = (int)(SWIG_As_int(obj4));
42487 if (SWIG_arg_fail(5)) SWIG_fail;
42488 }
42489 if (obj5) {
42490 arg6 = obj5;
42491 }
42492 {
42493 PyThreadState* __tstate = wxPyBeginAllowThreads();
42494 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42495
42496 wxPyEndAllowThreads(__tstate);
42497 if (PyErr_Occurred()) SWIG_fail;
42498 }
42499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42500 return resultobj;
42501 fail:
42502 return NULL;
42503 }
42504
42505
42506 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42507 PyObject *resultobj;
42508 int arg1 ;
42509 int arg2 ;
42510 wxGBPosition *arg3 = 0 ;
42511 wxGBSpan *arg4 = 0 ;
42512 int arg5 ;
42513 int arg6 ;
42514 PyObject *arg7 = (PyObject *) NULL ;
42515 wxGBSizerItem *result;
42516 wxGBPosition temp3 ;
42517 wxGBSpan temp4 ;
42518 PyObject * obj0 = 0 ;
42519 PyObject * obj1 = 0 ;
42520 PyObject * obj2 = 0 ;
42521 PyObject * obj3 = 0 ;
42522 PyObject * obj4 = 0 ;
42523 PyObject * obj5 = 0 ;
42524 PyObject * obj6 = 0 ;
42525 char *kwnames[] = {
42526 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42527 };
42528
42529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42530 {
42531 arg1 = (int)(SWIG_As_int(obj0));
42532 if (SWIG_arg_fail(1)) SWIG_fail;
42533 }
42534 {
42535 arg2 = (int)(SWIG_As_int(obj1));
42536 if (SWIG_arg_fail(2)) SWIG_fail;
42537 }
42538 {
42539 arg3 = &temp3;
42540 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42541 }
42542 {
42543 arg4 = &temp4;
42544 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42545 }
42546 {
42547 arg5 = (int)(SWIG_As_int(obj4));
42548 if (SWIG_arg_fail(5)) SWIG_fail;
42549 }
42550 {
42551 arg6 = (int)(SWIG_As_int(obj5));
42552 if (SWIG_arg_fail(6)) SWIG_fail;
42553 }
42554 if (obj6) {
42555 arg7 = obj6;
42556 }
42557 {
42558 PyThreadState* __tstate = wxPyBeginAllowThreads();
42559 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42560
42561 wxPyEndAllowThreads(__tstate);
42562 if (PyErr_Occurred()) SWIG_fail;
42563 }
42564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42565 return resultobj;
42566 fail:
42567 return NULL;
42568 }
42569
42570
42571 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42572 PyObject *resultobj;
42573 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42574 wxGBPosition result;
42575 PyObject * obj0 = 0 ;
42576 char *kwnames[] = {
42577 (char *) "self", NULL
42578 };
42579
42580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42582 if (SWIG_arg_fail(1)) SWIG_fail;
42583 {
42584 PyThreadState* __tstate = wxPyBeginAllowThreads();
42585 result = ((wxGBSizerItem const *)arg1)->GetPos();
42586
42587 wxPyEndAllowThreads(__tstate);
42588 if (PyErr_Occurred()) SWIG_fail;
42589 }
42590 {
42591 wxGBPosition * resultptr;
42592 resultptr = new wxGBPosition((wxGBPosition &)(result));
42593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42594 }
42595 return resultobj;
42596 fail:
42597 return NULL;
42598 }
42599
42600
42601 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42602 PyObject *resultobj;
42603 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42604 wxGBSpan result;
42605 PyObject * obj0 = 0 ;
42606 char *kwnames[] = {
42607 (char *) "self", NULL
42608 };
42609
42610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42612 if (SWIG_arg_fail(1)) SWIG_fail;
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42616
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 wxGBSpan * resultptr;
42622 resultptr = new wxGBSpan((wxGBSpan &)(result));
42623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42624 }
42625 return resultobj;
42626 fail:
42627 return NULL;
42628 }
42629
42630
42631 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42632 PyObject *resultobj;
42633 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42634 wxGBPosition *arg2 = 0 ;
42635 bool result;
42636 wxGBPosition temp2 ;
42637 PyObject * obj0 = 0 ;
42638 PyObject * obj1 = 0 ;
42639 char *kwnames[] = {
42640 (char *) "self",(char *) "pos", NULL
42641 };
42642
42643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42645 if (SWIG_arg_fail(1)) SWIG_fail;
42646 {
42647 arg2 = &temp2;
42648 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42649 }
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42653
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 {
42658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42659 }
42660 return resultobj;
42661 fail:
42662 return NULL;
42663 }
42664
42665
42666 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42667 PyObject *resultobj;
42668 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42669 wxGBSpan *arg2 = 0 ;
42670 bool result;
42671 wxGBSpan temp2 ;
42672 PyObject * obj0 = 0 ;
42673 PyObject * obj1 = 0 ;
42674 char *kwnames[] = {
42675 (char *) "self",(char *) "span", NULL
42676 };
42677
42678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42680 if (SWIG_arg_fail(1)) SWIG_fail;
42681 {
42682 arg2 = &temp2;
42683 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42684 }
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42688
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42694 }
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42702 PyObject *resultobj;
42703 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42704 wxGBSizerItem *arg2 = 0 ;
42705 bool result;
42706 PyObject * obj0 = 0 ;
42707 PyObject * obj1 = 0 ;
42708 char *kwnames[] = {
42709 (char *) "self",(char *) "other", NULL
42710 };
42711
42712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42714 if (SWIG_arg_fail(1)) SWIG_fail;
42715 {
42716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42717 if (SWIG_arg_fail(2)) SWIG_fail;
42718 if (arg2 == NULL) {
42719 SWIG_null_ref("wxGBSizerItem");
42720 }
42721 if (SWIG_arg_fail(2)) SWIG_fail;
42722 }
42723 {
42724 PyThreadState* __tstate = wxPyBeginAllowThreads();
42725 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42726
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 {
42731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42732 }
42733 return resultobj;
42734 fail:
42735 return NULL;
42736 }
42737
42738
42739 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42740 PyObject *resultobj;
42741 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42742 wxGBPosition *arg2 = 0 ;
42743 wxGBSpan *arg3 = 0 ;
42744 bool result;
42745 wxGBPosition temp2 ;
42746 wxGBSpan temp3 ;
42747 PyObject * obj0 = 0 ;
42748 PyObject * obj1 = 0 ;
42749 PyObject * obj2 = 0 ;
42750 char *kwnames[] = {
42751 (char *) "self",(char *) "pos",(char *) "span", NULL
42752 };
42753
42754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42756 if (SWIG_arg_fail(1)) SWIG_fail;
42757 {
42758 arg2 = &temp2;
42759 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42760 }
42761 {
42762 arg3 = &temp3;
42763 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42764 }
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42768
42769 wxPyEndAllowThreads(__tstate);
42770 if (PyErr_Occurred()) SWIG_fail;
42771 }
42772 {
42773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42774 }
42775 return resultobj;
42776 fail:
42777 return NULL;
42778 }
42779
42780
42781 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42782 PyObject *resultobj;
42783 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42784 wxGBPosition result;
42785 PyObject * obj0 = 0 ;
42786 char *kwnames[] = {
42787 (char *) "self", NULL
42788 };
42789
42790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42792 if (SWIG_arg_fail(1)) SWIG_fail;
42793 {
42794 PyThreadState* __tstate = wxPyBeginAllowThreads();
42795 result = wxGBSizerItem_GetEndPos(arg1);
42796
42797 wxPyEndAllowThreads(__tstate);
42798 if (PyErr_Occurred()) SWIG_fail;
42799 }
42800 {
42801 wxGBPosition * resultptr;
42802 resultptr = new wxGBPosition((wxGBPosition &)(result));
42803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42804 }
42805 return resultobj;
42806 fail:
42807 return NULL;
42808 }
42809
42810
42811 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42812 PyObject *resultobj;
42813 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42814 wxGridBagSizer *result;
42815 PyObject * obj0 = 0 ;
42816 char *kwnames[] = {
42817 (char *) "self", NULL
42818 };
42819
42820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42822 if (SWIG_arg_fail(1)) SWIG_fail;
42823 {
42824 PyThreadState* __tstate = wxPyBeginAllowThreads();
42825 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42826
42827 wxPyEndAllowThreads(__tstate);
42828 if (PyErr_Occurred()) SWIG_fail;
42829 }
42830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42838 PyObject *resultobj;
42839 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42840 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42841 PyObject * obj0 = 0 ;
42842 PyObject * obj1 = 0 ;
42843 char *kwnames[] = {
42844 (char *) "self",(char *) "sizer", NULL
42845 };
42846
42847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42849 if (SWIG_arg_fail(1)) SWIG_fail;
42850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42851 if (SWIG_arg_fail(2)) SWIG_fail;
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 (arg1)->SetGBSizer(arg2);
42855
42856 wxPyEndAllowThreads(__tstate);
42857 if (PyErr_Occurred()) SWIG_fail;
42858 }
42859 Py_INCREF(Py_None); resultobj = Py_None;
42860 return resultobj;
42861 fail:
42862 return NULL;
42863 }
42864
42865
42866 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42867 PyObject *obj;
42868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42869 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42870 Py_INCREF(obj);
42871 return Py_BuildValue((char *)"");
42872 }
42873 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42874 PyObject *resultobj;
42875 int arg1 = (int) 0 ;
42876 int arg2 = (int) 0 ;
42877 wxGridBagSizer *result;
42878 PyObject * obj0 = 0 ;
42879 PyObject * obj1 = 0 ;
42880 char *kwnames[] = {
42881 (char *) "vgap",(char *) "hgap", NULL
42882 };
42883
42884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42885 if (obj0) {
42886 {
42887 arg1 = (int)(SWIG_As_int(obj0));
42888 if (SWIG_arg_fail(1)) SWIG_fail;
42889 }
42890 }
42891 if (obj1) {
42892 {
42893 arg2 = (int)(SWIG_As_int(obj1));
42894 if (SWIG_arg_fail(2)) SWIG_fail;
42895 }
42896 }
42897 {
42898 PyThreadState* __tstate = wxPyBeginAllowThreads();
42899 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42900
42901 wxPyEndAllowThreads(__tstate);
42902 if (PyErr_Occurred()) SWIG_fail;
42903 }
42904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42905 return resultobj;
42906 fail:
42907 return NULL;
42908 }
42909
42910
42911 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42912 PyObject *resultobj;
42913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42914 PyObject *arg2 = (PyObject *) 0 ;
42915 wxGBPosition *arg3 = 0 ;
42916 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42917 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42918 int arg5 = (int) 0 ;
42919 int arg6 = (int) 0 ;
42920 PyObject *arg7 = (PyObject *) NULL ;
42921 wxGBSizerItem *result;
42922 wxGBPosition temp3 ;
42923 wxGBSpan temp4 ;
42924 PyObject * obj0 = 0 ;
42925 PyObject * obj1 = 0 ;
42926 PyObject * obj2 = 0 ;
42927 PyObject * obj3 = 0 ;
42928 PyObject * obj4 = 0 ;
42929 PyObject * obj5 = 0 ;
42930 PyObject * obj6 = 0 ;
42931 char *kwnames[] = {
42932 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42933 };
42934
42935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42937 if (SWIG_arg_fail(1)) SWIG_fail;
42938 arg2 = obj1;
42939 {
42940 arg3 = &temp3;
42941 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42942 }
42943 if (obj3) {
42944 {
42945 arg4 = &temp4;
42946 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42947 }
42948 }
42949 if (obj4) {
42950 {
42951 arg5 = (int)(SWIG_As_int(obj4));
42952 if (SWIG_arg_fail(5)) SWIG_fail;
42953 }
42954 }
42955 if (obj5) {
42956 {
42957 arg6 = (int)(SWIG_As_int(obj5));
42958 if (SWIG_arg_fail(6)) SWIG_fail;
42959 }
42960 }
42961 if (obj6) {
42962 arg7 = obj6;
42963 }
42964 {
42965 PyThreadState* __tstate = wxPyBeginAllowThreads();
42966 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42967
42968 wxPyEndAllowThreads(__tstate);
42969 if (PyErr_Occurred()) SWIG_fail;
42970 }
42971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42972 return resultobj;
42973 fail:
42974 return NULL;
42975 }
42976
42977
42978 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42979 PyObject *resultobj;
42980 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42981 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42982 wxGBSizerItem *result;
42983 PyObject * obj0 = 0 ;
42984 PyObject * obj1 = 0 ;
42985 char *kwnames[] = {
42986 (char *) "self",(char *) "item", NULL
42987 };
42988
42989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42991 if (SWIG_arg_fail(1)) SWIG_fail;
42992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42993 if (SWIG_arg_fail(2)) SWIG_fail;
42994 {
42995 PyThreadState* __tstate = wxPyBeginAllowThreads();
42996 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42997
42998 wxPyEndAllowThreads(__tstate);
42999 if (PyErr_Occurred()) SWIG_fail;
43000 }
43001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43002 return resultobj;
43003 fail:
43004 return NULL;
43005 }
43006
43007
43008 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43009 PyObject *resultobj;
43010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43011 int arg2 ;
43012 int arg3 ;
43013 wxSize result;
43014 PyObject * obj0 = 0 ;
43015 PyObject * obj1 = 0 ;
43016 PyObject * obj2 = 0 ;
43017 char *kwnames[] = {
43018 (char *) "self",(char *) "row",(char *) "col", NULL
43019 };
43020
43021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43023 if (SWIG_arg_fail(1)) SWIG_fail;
43024 {
43025 arg2 = (int)(SWIG_As_int(obj1));
43026 if (SWIG_arg_fail(2)) SWIG_fail;
43027 }
43028 {
43029 arg3 = (int)(SWIG_As_int(obj2));
43030 if (SWIG_arg_fail(3)) SWIG_fail;
43031 }
43032 {
43033 PyThreadState* __tstate = wxPyBeginAllowThreads();
43034 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43035
43036 wxPyEndAllowThreads(__tstate);
43037 if (PyErr_Occurred()) SWIG_fail;
43038 }
43039 {
43040 wxSize * resultptr;
43041 resultptr = new wxSize((wxSize &)(result));
43042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43043 }
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43051 PyObject *resultobj;
43052 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43053 wxSize result;
43054 PyObject * obj0 = 0 ;
43055 char *kwnames[] = {
43056 (char *) "self", NULL
43057 };
43058
43059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43061 if (SWIG_arg_fail(1)) SWIG_fail;
43062 {
43063 PyThreadState* __tstate = wxPyBeginAllowThreads();
43064 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43065
43066 wxPyEndAllowThreads(__tstate);
43067 if (PyErr_Occurred()) SWIG_fail;
43068 }
43069 {
43070 wxSize * resultptr;
43071 resultptr = new wxSize((wxSize &)(result));
43072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43073 }
43074 return resultobj;
43075 fail:
43076 return NULL;
43077 }
43078
43079
43080 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43081 PyObject *resultobj;
43082 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43083 wxSize *arg2 = 0 ;
43084 wxSize temp2 ;
43085 PyObject * obj0 = 0 ;
43086 PyObject * obj1 = 0 ;
43087 char *kwnames[] = {
43088 (char *) "self",(char *) "sz", NULL
43089 };
43090
43091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43093 if (SWIG_arg_fail(1)) SWIG_fail;
43094 {
43095 arg2 = &temp2;
43096 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43097 }
43098 {
43099 PyThreadState* __tstate = wxPyBeginAllowThreads();
43100 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43101
43102 wxPyEndAllowThreads(__tstate);
43103 if (PyErr_Occurred()) SWIG_fail;
43104 }
43105 Py_INCREF(Py_None); resultobj = Py_None;
43106 return resultobj;
43107 fail:
43108 return NULL;
43109 }
43110
43111
43112 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43113 PyObject *resultobj;
43114 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43115 wxWindow *arg2 = (wxWindow *) 0 ;
43116 wxGBPosition result;
43117 PyObject * obj0 = 0 ;
43118 PyObject * obj1 = 0 ;
43119
43120 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43122 if (SWIG_arg_fail(1)) SWIG_fail;
43123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43124 if (SWIG_arg_fail(2)) SWIG_fail;
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = (arg1)->GetItemPosition(arg2);
43128
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 {
43133 wxGBPosition * resultptr;
43134 resultptr = new wxGBPosition((wxGBPosition &)(result));
43135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43136 }
43137 return resultobj;
43138 fail:
43139 return NULL;
43140 }
43141
43142
43143 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43144 PyObject *resultobj;
43145 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43146 wxSizer *arg2 = (wxSizer *) 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_wxSizer, 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_2(PyObject *, PyObject *args) {
43175 PyObject *resultobj;
43176 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43177 size_t arg2 ;
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 {
43186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43187 if (SWIG_arg_fail(2)) SWIG_fail;
43188 }
43189 {
43190 PyThreadState* __tstate = wxPyBeginAllowThreads();
43191 result = (arg1)->GetItemPosition(arg2);
43192
43193 wxPyEndAllowThreads(__tstate);
43194 if (PyErr_Occurred()) SWIG_fail;
43195 }
43196 {
43197 wxGBPosition * resultptr;
43198 resultptr = new wxGBPosition((wxGBPosition &)(result));
43199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43200 }
43201 return resultobj;
43202 fail:
43203 return NULL;
43204 }
43205
43206
43207 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43208 int argc;
43209 PyObject *argv[3];
43210 int ii;
43211
43212 argc = PyObject_Length(args);
43213 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43214 argv[ii] = PyTuple_GetItem(args,ii);
43215 }
43216 if (argc == 2) {
43217 int _v;
43218 {
43219 void *ptr;
43220 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43221 _v = 0;
43222 PyErr_Clear();
43223 } else {
43224 _v = 1;
43225 }
43226 }
43227 if (_v) {
43228 {
43229 void *ptr;
43230 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43231 _v = 0;
43232 PyErr_Clear();
43233 } else {
43234 _v = 1;
43235 }
43236 }
43237 if (_v) {
43238 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43239 }
43240 }
43241 }
43242 if (argc == 2) {
43243 int _v;
43244 {
43245 void *ptr;
43246 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43247 _v = 0;
43248 PyErr_Clear();
43249 } else {
43250 _v = 1;
43251 }
43252 }
43253 if (_v) {
43254 {
43255 void *ptr;
43256 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43257 _v = 0;
43258 PyErr_Clear();
43259 } else {
43260 _v = 1;
43261 }
43262 }
43263 if (_v) {
43264 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43265 }
43266 }
43267 }
43268 if (argc == 2) {
43269 int _v;
43270 {
43271 void *ptr;
43272 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43273 _v = 0;
43274 PyErr_Clear();
43275 } else {
43276 _v = 1;
43277 }
43278 }
43279 if (_v) {
43280 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43281 if (_v) {
43282 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43283 }
43284 }
43285 }
43286
43287 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43288 return NULL;
43289 }
43290
43291
43292 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43293 PyObject *resultobj;
43294 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43295 wxWindow *arg2 = (wxWindow *) 0 ;
43296 wxGBPosition *arg3 = 0 ;
43297 bool result;
43298 wxGBPosition temp3 ;
43299 PyObject * obj0 = 0 ;
43300 PyObject * obj1 = 0 ;
43301 PyObject * obj2 = 0 ;
43302
43303 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43305 if (SWIG_arg_fail(1)) SWIG_fail;
43306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43307 if (SWIG_arg_fail(2)) SWIG_fail;
43308 {
43309 arg3 = &temp3;
43310 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43311 }
43312 {
43313 PyThreadState* __tstate = wxPyBeginAllowThreads();
43314 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43315
43316 wxPyEndAllowThreads(__tstate);
43317 if (PyErr_Occurred()) SWIG_fail;
43318 }
43319 {
43320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43321 }
43322 return resultobj;
43323 fail:
43324 return NULL;
43325 }
43326
43327
43328 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43329 PyObject *resultobj;
43330 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43331 wxSizer *arg2 = (wxSizer *) 0 ;
43332 wxGBPosition *arg3 = 0 ;
43333 bool result;
43334 wxGBPosition temp3 ;
43335 PyObject * obj0 = 0 ;
43336 PyObject * obj1 = 0 ;
43337 PyObject * obj2 = 0 ;
43338
43339 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43341 if (SWIG_arg_fail(1)) SWIG_fail;
43342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43343 if (SWIG_arg_fail(2)) SWIG_fail;
43344 {
43345 arg3 = &temp3;
43346 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43347 }
43348 {
43349 PyThreadState* __tstate = wxPyBeginAllowThreads();
43350 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43351
43352 wxPyEndAllowThreads(__tstate);
43353 if (PyErr_Occurred()) SWIG_fail;
43354 }
43355 {
43356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43357 }
43358 return resultobj;
43359 fail:
43360 return NULL;
43361 }
43362
43363
43364 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43365 PyObject *resultobj;
43366 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43367 size_t arg2 ;
43368 wxGBPosition *arg3 = 0 ;
43369 bool result;
43370 wxGBPosition temp3 ;
43371 PyObject * obj0 = 0 ;
43372 PyObject * obj1 = 0 ;
43373 PyObject * obj2 = 0 ;
43374
43375 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43377 if (SWIG_arg_fail(1)) SWIG_fail;
43378 {
43379 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43380 if (SWIG_arg_fail(2)) SWIG_fail;
43381 }
43382 {
43383 arg3 = &temp3;
43384 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43385 }
43386 {
43387 PyThreadState* __tstate = wxPyBeginAllowThreads();
43388 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43389
43390 wxPyEndAllowThreads(__tstate);
43391 if (PyErr_Occurred()) SWIG_fail;
43392 }
43393 {
43394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43395 }
43396 return resultobj;
43397 fail:
43398 return NULL;
43399 }
43400
43401
43402 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43403 int argc;
43404 PyObject *argv[4];
43405 int ii;
43406
43407 argc = PyObject_Length(args);
43408 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43409 argv[ii] = PyTuple_GetItem(args,ii);
43410 }
43411 if (argc == 3) {
43412 int _v;
43413 {
43414 void *ptr;
43415 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43416 _v = 0;
43417 PyErr_Clear();
43418 } else {
43419 _v = 1;
43420 }
43421 }
43422 if (_v) {
43423 {
43424 void *ptr;
43425 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43426 _v = 0;
43427 PyErr_Clear();
43428 } else {
43429 _v = 1;
43430 }
43431 }
43432 if (_v) {
43433 {
43434 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43435 }
43436 if (_v) {
43437 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43438 }
43439 }
43440 }
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_wxSizer, 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_1(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 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43486 if (_v) {
43487 {
43488 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43489 }
43490 if (_v) {
43491 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43492 }
43493 }
43494 }
43495 }
43496
43497 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43498 return NULL;
43499 }
43500
43501
43502 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43503 PyObject *resultobj;
43504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43505 wxWindow *arg2 = (wxWindow *) 0 ;
43506 wxGBSpan result;
43507 PyObject * obj0 = 0 ;
43508 PyObject * obj1 = 0 ;
43509
43510 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43512 if (SWIG_arg_fail(1)) SWIG_fail;
43513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43514 if (SWIG_arg_fail(2)) SWIG_fail;
43515 {
43516 PyThreadState* __tstate = wxPyBeginAllowThreads();
43517 result = (arg1)->GetItemSpan(arg2);
43518
43519 wxPyEndAllowThreads(__tstate);
43520 if (PyErr_Occurred()) SWIG_fail;
43521 }
43522 {
43523 wxGBSpan * resultptr;
43524 resultptr = new wxGBSpan((wxGBSpan &)(result));
43525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43526 }
43527 return resultobj;
43528 fail:
43529 return NULL;
43530 }
43531
43532
43533 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43534 PyObject *resultobj;
43535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43536 wxSizer *arg2 = (wxSizer *) 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_wxSizer, 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_2(PyObject *, PyObject *args) {
43565 PyObject *resultobj;
43566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43567 size_t arg2 ;
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 {
43576 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43577 if (SWIG_arg_fail(2)) SWIG_fail;
43578 }
43579 {
43580 PyThreadState* __tstate = wxPyBeginAllowThreads();
43581 result = (arg1)->GetItemSpan(arg2);
43582
43583 wxPyEndAllowThreads(__tstate);
43584 if (PyErr_Occurred()) SWIG_fail;
43585 }
43586 {
43587 wxGBSpan * resultptr;
43588 resultptr = new wxGBSpan((wxGBSpan &)(result));
43589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43590 }
43591 return resultobj;
43592 fail:
43593 return NULL;
43594 }
43595
43596
43597 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43598 int argc;
43599 PyObject *argv[3];
43600 int ii;
43601
43602 argc = PyObject_Length(args);
43603 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43604 argv[ii] = PyTuple_GetItem(args,ii);
43605 }
43606 if (argc == 2) {
43607 int _v;
43608 {
43609 void *ptr;
43610 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43611 _v = 0;
43612 PyErr_Clear();
43613 } else {
43614 _v = 1;
43615 }
43616 }
43617 if (_v) {
43618 {
43619 void *ptr;
43620 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43621 _v = 0;
43622 PyErr_Clear();
43623 } else {
43624 _v = 1;
43625 }
43626 }
43627 if (_v) {
43628 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43629 }
43630 }
43631 }
43632 if (argc == 2) {
43633 int _v;
43634 {
43635 void *ptr;
43636 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43637 _v = 0;
43638 PyErr_Clear();
43639 } else {
43640 _v = 1;
43641 }
43642 }
43643 if (_v) {
43644 {
43645 void *ptr;
43646 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43647 _v = 0;
43648 PyErr_Clear();
43649 } else {
43650 _v = 1;
43651 }
43652 }
43653 if (_v) {
43654 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43655 }
43656 }
43657 }
43658 if (argc == 2) {
43659 int _v;
43660 {
43661 void *ptr;
43662 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43663 _v = 0;
43664 PyErr_Clear();
43665 } else {
43666 _v = 1;
43667 }
43668 }
43669 if (_v) {
43670 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43671 if (_v) {
43672 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43673 }
43674 }
43675 }
43676
43677 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43678 return NULL;
43679 }
43680
43681
43682 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43683 PyObject *resultobj;
43684 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43685 wxWindow *arg2 = (wxWindow *) 0 ;
43686 wxGBSpan *arg3 = 0 ;
43687 bool result;
43688 wxGBSpan temp3 ;
43689 PyObject * obj0 = 0 ;
43690 PyObject * obj1 = 0 ;
43691 PyObject * obj2 = 0 ;
43692
43693 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43695 if (SWIG_arg_fail(1)) SWIG_fail;
43696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43697 if (SWIG_arg_fail(2)) SWIG_fail;
43698 {
43699 arg3 = &temp3;
43700 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43701 }
43702 {
43703 PyThreadState* __tstate = wxPyBeginAllowThreads();
43704 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43705
43706 wxPyEndAllowThreads(__tstate);
43707 if (PyErr_Occurred()) SWIG_fail;
43708 }
43709 {
43710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43711 }
43712 return resultobj;
43713 fail:
43714 return NULL;
43715 }
43716
43717
43718 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43719 PyObject *resultobj;
43720 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43721 wxSizer *arg2 = (wxSizer *) 0 ;
43722 wxGBSpan *arg3 = 0 ;
43723 bool result;
43724 wxGBSpan temp3 ;
43725 PyObject * obj0 = 0 ;
43726 PyObject * obj1 = 0 ;
43727 PyObject * obj2 = 0 ;
43728
43729 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43731 if (SWIG_arg_fail(1)) SWIG_fail;
43732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43733 if (SWIG_arg_fail(2)) SWIG_fail;
43734 {
43735 arg3 = &temp3;
43736 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43737 }
43738 {
43739 PyThreadState* __tstate = wxPyBeginAllowThreads();
43740 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43741
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 {
43746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43747 }
43748 return resultobj;
43749 fail:
43750 return NULL;
43751 }
43752
43753
43754 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43755 PyObject *resultobj;
43756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43757 size_t arg2 ;
43758 wxGBSpan *arg3 = 0 ;
43759 bool result;
43760 wxGBSpan temp3 ;
43761 PyObject * obj0 = 0 ;
43762 PyObject * obj1 = 0 ;
43763 PyObject * obj2 = 0 ;
43764
43765 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43767 if (SWIG_arg_fail(1)) SWIG_fail;
43768 {
43769 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43770 if (SWIG_arg_fail(2)) SWIG_fail;
43771 }
43772 {
43773 arg3 = &temp3;
43774 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43775 }
43776 {
43777 PyThreadState* __tstate = wxPyBeginAllowThreads();
43778 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43779
43780 wxPyEndAllowThreads(__tstate);
43781 if (PyErr_Occurred()) SWIG_fail;
43782 }
43783 {
43784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43785 }
43786 return resultobj;
43787 fail:
43788 return NULL;
43789 }
43790
43791
43792 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43793 int argc;
43794 PyObject *argv[4];
43795 int ii;
43796
43797 argc = PyObject_Length(args);
43798 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43799 argv[ii] = PyTuple_GetItem(args,ii);
43800 }
43801 if (argc == 3) {
43802 int _v;
43803 {
43804 void *ptr;
43805 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43806 _v = 0;
43807 PyErr_Clear();
43808 } else {
43809 _v = 1;
43810 }
43811 }
43812 if (_v) {
43813 {
43814 void *ptr;
43815 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43816 _v = 0;
43817 PyErr_Clear();
43818 } else {
43819 _v = 1;
43820 }
43821 }
43822 if (_v) {
43823 {
43824 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43825 }
43826 if (_v) {
43827 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43828 }
43829 }
43830 }
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_wxSizer, 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_1(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 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43876 if (_v) {
43877 {
43878 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43879 }
43880 if (_v) {
43881 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43882 }
43883 }
43884 }
43885 }
43886
43887 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43888 return NULL;
43889 }
43890
43891
43892 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43893 PyObject *resultobj;
43894 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43895 wxWindow *arg2 = (wxWindow *) 0 ;
43896 wxGBSizerItem *result;
43897 PyObject * obj0 = 0 ;
43898 PyObject * obj1 = 0 ;
43899
43900 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43902 if (SWIG_arg_fail(1)) SWIG_fail;
43903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43904 if (SWIG_arg_fail(2)) SWIG_fail;
43905 {
43906 PyThreadState* __tstate = wxPyBeginAllowThreads();
43907 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43908
43909 wxPyEndAllowThreads(__tstate);
43910 if (PyErr_Occurred()) SWIG_fail;
43911 }
43912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43913 return resultobj;
43914 fail:
43915 return NULL;
43916 }
43917
43918
43919 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43920 PyObject *resultobj;
43921 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43922 wxSizer *arg2 = (wxSizer *) 0 ;
43923 wxGBSizerItem *result;
43924 PyObject * obj0 = 0 ;
43925 PyObject * obj1 = 0 ;
43926
43927 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43929 if (SWIG_arg_fail(1)) SWIG_fail;
43930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43931 if (SWIG_arg_fail(2)) SWIG_fail;
43932 {
43933 PyThreadState* __tstate = wxPyBeginAllowThreads();
43934 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43935
43936 wxPyEndAllowThreads(__tstate);
43937 if (PyErr_Occurred()) SWIG_fail;
43938 }
43939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43940 return resultobj;
43941 fail:
43942 return NULL;
43943 }
43944
43945
43946 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43947 int argc;
43948 PyObject *argv[3];
43949 int ii;
43950
43951 argc = PyObject_Length(args);
43952 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43953 argv[ii] = PyTuple_GetItem(args,ii);
43954 }
43955 if (argc == 2) {
43956 int _v;
43957 {
43958 void *ptr;
43959 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43960 _v = 0;
43961 PyErr_Clear();
43962 } else {
43963 _v = 1;
43964 }
43965 }
43966 if (_v) {
43967 {
43968 void *ptr;
43969 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43970 _v = 0;
43971 PyErr_Clear();
43972 } else {
43973 _v = 1;
43974 }
43975 }
43976 if (_v) {
43977 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43978 }
43979 }
43980 }
43981 if (argc == 2) {
43982 int _v;
43983 {
43984 void *ptr;
43985 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43986 _v = 0;
43987 PyErr_Clear();
43988 } else {
43989 _v = 1;
43990 }
43991 }
43992 if (_v) {
43993 {
43994 void *ptr;
43995 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43996 _v = 0;
43997 PyErr_Clear();
43998 } else {
43999 _v = 1;
44000 }
44001 }
44002 if (_v) {
44003 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44004 }
44005 }
44006 }
44007
44008 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44009 return NULL;
44010 }
44011
44012
44013 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44014 PyObject *resultobj;
44015 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44016 wxGBPosition *arg2 = 0 ;
44017 wxGBSizerItem *result;
44018 wxGBPosition temp2 ;
44019 PyObject * obj0 = 0 ;
44020 PyObject * obj1 = 0 ;
44021 char *kwnames[] = {
44022 (char *) "self",(char *) "pos", NULL
44023 };
44024
44025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44027 if (SWIG_arg_fail(1)) SWIG_fail;
44028 {
44029 arg2 = &temp2;
44030 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44031 }
44032 {
44033 PyThreadState* __tstate = wxPyBeginAllowThreads();
44034 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44035
44036 wxPyEndAllowThreads(__tstate);
44037 if (PyErr_Occurred()) SWIG_fail;
44038 }
44039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44040 return resultobj;
44041 fail:
44042 return NULL;
44043 }
44044
44045
44046 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44047 PyObject *resultobj;
44048 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44049 wxPoint *arg2 = 0 ;
44050 wxGBSizerItem *result;
44051 wxPoint temp2 ;
44052 PyObject * obj0 = 0 ;
44053 PyObject * obj1 = 0 ;
44054 char *kwnames[] = {
44055 (char *) "self",(char *) "pt", NULL
44056 };
44057
44058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44060 if (SWIG_arg_fail(1)) SWIG_fail;
44061 {
44062 arg2 = &temp2;
44063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44064 }
44065 {
44066 PyThreadState* __tstate = wxPyBeginAllowThreads();
44067 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44068
44069 wxPyEndAllowThreads(__tstate);
44070 if (PyErr_Occurred()) SWIG_fail;
44071 }
44072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44073 return resultobj;
44074 fail:
44075 return NULL;
44076 }
44077
44078
44079 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44080 PyObject *resultobj;
44081 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44082 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44083 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44084 bool result;
44085 PyObject * obj0 = 0 ;
44086 PyObject * obj1 = 0 ;
44087 PyObject * obj2 = 0 ;
44088 char *kwnames[] = {
44089 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44090 };
44091
44092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44094 if (SWIG_arg_fail(1)) SWIG_fail;
44095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44096 if (SWIG_arg_fail(2)) SWIG_fail;
44097 if (obj2) {
44098 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44099 if (SWIG_arg_fail(3)) SWIG_fail;
44100 }
44101 {
44102 PyThreadState* __tstate = wxPyBeginAllowThreads();
44103 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44104
44105 wxPyEndAllowThreads(__tstate);
44106 if (PyErr_Occurred()) SWIG_fail;
44107 }
44108 {
44109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44110 }
44111 return resultobj;
44112 fail:
44113 return NULL;
44114 }
44115
44116
44117 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44118 PyObject *resultobj;
44119 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44120 wxGBPosition *arg2 = 0 ;
44121 wxGBSpan *arg3 = 0 ;
44122 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44123 bool result;
44124 wxGBPosition temp2 ;
44125 wxGBSpan temp3 ;
44126 PyObject * obj0 = 0 ;
44127 PyObject * obj1 = 0 ;
44128 PyObject * obj2 = 0 ;
44129 PyObject * obj3 = 0 ;
44130 char *kwnames[] = {
44131 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44132 };
44133
44134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44136 if (SWIG_arg_fail(1)) SWIG_fail;
44137 {
44138 arg2 = &temp2;
44139 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44140 }
44141 {
44142 arg3 = &temp3;
44143 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44144 }
44145 if (obj3) {
44146 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44147 if (SWIG_arg_fail(4)) SWIG_fail;
44148 }
44149 {
44150 PyThreadState* __tstate = wxPyBeginAllowThreads();
44151 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44152
44153 wxPyEndAllowThreads(__tstate);
44154 if (PyErr_Occurred()) SWIG_fail;
44155 }
44156 {
44157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44158 }
44159 return resultobj;
44160 fail:
44161 return NULL;
44162 }
44163
44164
44165 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44166 PyObject *obj;
44167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44168 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44169 Py_INCREF(obj);
44170 return Py_BuildValue((char *)"");
44171 }
44172 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44173 PyObject *resultobj;
44174 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44175 wxRelationship arg2 ;
44176 wxWindow *arg3 = (wxWindow *) 0 ;
44177 wxEdge arg4 ;
44178 int arg5 = (int) 0 ;
44179 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44180 PyObject * obj0 = 0 ;
44181 PyObject * obj1 = 0 ;
44182 PyObject * obj2 = 0 ;
44183 PyObject * obj3 = 0 ;
44184 PyObject * obj4 = 0 ;
44185 PyObject * obj5 = 0 ;
44186 char *kwnames[] = {
44187 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44188 };
44189
44190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44192 if (SWIG_arg_fail(1)) SWIG_fail;
44193 {
44194 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44195 if (SWIG_arg_fail(2)) SWIG_fail;
44196 }
44197 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44198 if (SWIG_arg_fail(3)) SWIG_fail;
44199 {
44200 arg4 = (wxEdge)(SWIG_As_int(obj3));
44201 if (SWIG_arg_fail(4)) SWIG_fail;
44202 }
44203 if (obj4) {
44204 {
44205 arg5 = (int)(SWIG_As_int(obj4));
44206 if (SWIG_arg_fail(5)) SWIG_fail;
44207 }
44208 }
44209 if (obj5) {
44210 {
44211 arg6 = (int)(SWIG_As_int(obj5));
44212 if (SWIG_arg_fail(6)) SWIG_fail;
44213 }
44214 }
44215 {
44216 PyThreadState* __tstate = wxPyBeginAllowThreads();
44217 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44218
44219 wxPyEndAllowThreads(__tstate);
44220 if (PyErr_Occurred()) SWIG_fail;
44221 }
44222 Py_INCREF(Py_None); resultobj = Py_None;
44223 return resultobj;
44224 fail:
44225 return NULL;
44226 }
44227
44228
44229 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44230 PyObject *resultobj;
44231 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44232 wxWindow *arg2 = (wxWindow *) 0 ;
44233 int arg3 = (int) 0 ;
44234 PyObject * obj0 = 0 ;
44235 PyObject * obj1 = 0 ;
44236 PyObject * obj2 = 0 ;
44237 char *kwnames[] = {
44238 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44239 };
44240
44241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44243 if (SWIG_arg_fail(1)) SWIG_fail;
44244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44245 if (SWIG_arg_fail(2)) SWIG_fail;
44246 if (obj2) {
44247 {
44248 arg3 = (int)(SWIG_As_int(obj2));
44249 if (SWIG_arg_fail(3)) SWIG_fail;
44250 }
44251 }
44252 {
44253 PyThreadState* __tstate = wxPyBeginAllowThreads();
44254 (arg1)->LeftOf(arg2,arg3);
44255
44256 wxPyEndAllowThreads(__tstate);
44257 if (PyErr_Occurred()) SWIG_fail;
44258 }
44259 Py_INCREF(Py_None); resultobj = Py_None;
44260 return resultobj;
44261 fail:
44262 return NULL;
44263 }
44264
44265
44266 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44267 PyObject *resultobj;
44268 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44269 wxWindow *arg2 = (wxWindow *) 0 ;
44270 int arg3 = (int) 0 ;
44271 PyObject * obj0 = 0 ;
44272 PyObject * obj1 = 0 ;
44273 PyObject * obj2 = 0 ;
44274 char *kwnames[] = {
44275 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44276 };
44277
44278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44280 if (SWIG_arg_fail(1)) SWIG_fail;
44281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44282 if (SWIG_arg_fail(2)) SWIG_fail;
44283 if (obj2) {
44284 {
44285 arg3 = (int)(SWIG_As_int(obj2));
44286 if (SWIG_arg_fail(3)) SWIG_fail;
44287 }
44288 }
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 (arg1)->RightOf(arg2,arg3);
44292
44293 wxPyEndAllowThreads(__tstate);
44294 if (PyErr_Occurred()) SWIG_fail;
44295 }
44296 Py_INCREF(Py_None); resultobj = Py_None;
44297 return resultobj;
44298 fail:
44299 return NULL;
44300 }
44301
44302
44303 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44304 PyObject *resultobj;
44305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44306 wxWindow *arg2 = (wxWindow *) 0 ;
44307 int arg3 = (int) 0 ;
44308 PyObject * obj0 = 0 ;
44309 PyObject * obj1 = 0 ;
44310 PyObject * obj2 = 0 ;
44311 char *kwnames[] = {
44312 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44313 };
44314
44315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44317 if (SWIG_arg_fail(1)) SWIG_fail;
44318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44319 if (SWIG_arg_fail(2)) SWIG_fail;
44320 if (obj2) {
44321 {
44322 arg3 = (int)(SWIG_As_int(obj2));
44323 if (SWIG_arg_fail(3)) SWIG_fail;
44324 }
44325 }
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 (arg1)->Above(arg2,arg3);
44329
44330 wxPyEndAllowThreads(__tstate);
44331 if (PyErr_Occurred()) SWIG_fail;
44332 }
44333 Py_INCREF(Py_None); resultobj = Py_None;
44334 return resultobj;
44335 fail:
44336 return NULL;
44337 }
44338
44339
44340 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44341 PyObject *resultobj;
44342 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44343 wxWindow *arg2 = (wxWindow *) 0 ;
44344 int arg3 = (int) 0 ;
44345 PyObject * obj0 = 0 ;
44346 PyObject * obj1 = 0 ;
44347 PyObject * obj2 = 0 ;
44348 char *kwnames[] = {
44349 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44350 };
44351
44352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44354 if (SWIG_arg_fail(1)) SWIG_fail;
44355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44356 if (SWIG_arg_fail(2)) SWIG_fail;
44357 if (obj2) {
44358 {
44359 arg3 = (int)(SWIG_As_int(obj2));
44360 if (SWIG_arg_fail(3)) SWIG_fail;
44361 }
44362 }
44363 {
44364 PyThreadState* __tstate = wxPyBeginAllowThreads();
44365 (arg1)->Below(arg2,arg3);
44366
44367 wxPyEndAllowThreads(__tstate);
44368 if (PyErr_Occurred()) SWIG_fail;
44369 }
44370 Py_INCREF(Py_None); resultobj = Py_None;
44371 return resultobj;
44372 fail:
44373 return NULL;
44374 }
44375
44376
44377 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44378 PyObject *resultobj;
44379 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44380 wxWindow *arg2 = (wxWindow *) 0 ;
44381 wxEdge arg3 ;
44382 int arg4 = (int) 0 ;
44383 PyObject * obj0 = 0 ;
44384 PyObject * obj1 = 0 ;
44385 PyObject * obj2 = 0 ;
44386 PyObject * obj3 = 0 ;
44387 char *kwnames[] = {
44388 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44389 };
44390
44391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44393 if (SWIG_arg_fail(1)) SWIG_fail;
44394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44395 if (SWIG_arg_fail(2)) SWIG_fail;
44396 {
44397 arg3 = (wxEdge)(SWIG_As_int(obj2));
44398 if (SWIG_arg_fail(3)) SWIG_fail;
44399 }
44400 if (obj3) {
44401 {
44402 arg4 = (int)(SWIG_As_int(obj3));
44403 if (SWIG_arg_fail(4)) SWIG_fail;
44404 }
44405 }
44406 {
44407 PyThreadState* __tstate = wxPyBeginAllowThreads();
44408 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44409
44410 wxPyEndAllowThreads(__tstate);
44411 if (PyErr_Occurred()) SWIG_fail;
44412 }
44413 Py_INCREF(Py_None); resultobj = Py_None;
44414 return resultobj;
44415 fail:
44416 return NULL;
44417 }
44418
44419
44420 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44421 PyObject *resultobj;
44422 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44423 wxWindow *arg2 = (wxWindow *) 0 ;
44424 wxEdge arg3 ;
44425 int arg4 ;
44426 PyObject * obj0 = 0 ;
44427 PyObject * obj1 = 0 ;
44428 PyObject * obj2 = 0 ;
44429 PyObject * obj3 = 0 ;
44430 char *kwnames[] = {
44431 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44432 };
44433
44434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44436 if (SWIG_arg_fail(1)) SWIG_fail;
44437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44438 if (SWIG_arg_fail(2)) SWIG_fail;
44439 {
44440 arg3 = (wxEdge)(SWIG_As_int(obj2));
44441 if (SWIG_arg_fail(3)) SWIG_fail;
44442 }
44443 {
44444 arg4 = (int)(SWIG_As_int(obj3));
44445 if (SWIG_arg_fail(4)) SWIG_fail;
44446 }
44447 {
44448 PyThreadState* __tstate = wxPyBeginAllowThreads();
44449 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44450
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 Py_INCREF(Py_None); resultobj = Py_None;
44455 return resultobj;
44456 fail:
44457 return NULL;
44458 }
44459
44460
44461 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44462 PyObject *resultobj;
44463 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44464 int arg2 ;
44465 PyObject * obj0 = 0 ;
44466 PyObject * obj1 = 0 ;
44467 char *kwnames[] = {
44468 (char *) "self",(char *) "val", NULL
44469 };
44470
44471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44473 if (SWIG_arg_fail(1)) SWIG_fail;
44474 {
44475 arg2 = (int)(SWIG_As_int(obj1));
44476 if (SWIG_arg_fail(2)) SWIG_fail;
44477 }
44478 {
44479 PyThreadState* __tstate = wxPyBeginAllowThreads();
44480 (arg1)->Absolute(arg2);
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_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44493 PyObject *resultobj;
44494 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44495 PyObject * obj0 = 0 ;
44496 char *kwnames[] = {
44497 (char *) "self", NULL
44498 };
44499
44500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44502 if (SWIG_arg_fail(1)) SWIG_fail;
44503 {
44504 PyThreadState* __tstate = wxPyBeginAllowThreads();
44505 (arg1)->Unconstrained();
44506
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 Py_INCREF(Py_None); resultobj = Py_None;
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44518 PyObject *resultobj;
44519 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44520 PyObject * obj0 = 0 ;
44521 char *kwnames[] = {
44522 (char *) "self", NULL
44523 };
44524
44525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44527 if (SWIG_arg_fail(1)) SWIG_fail;
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 (arg1)->AsIs();
44531
44532 wxPyEndAllowThreads(__tstate);
44533 if (PyErr_Occurred()) SWIG_fail;
44534 }
44535 Py_INCREF(Py_None); resultobj = Py_None;
44536 return resultobj;
44537 fail:
44538 return NULL;
44539 }
44540
44541
44542 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44543 PyObject *resultobj;
44544 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44545 wxWindow *result;
44546 PyObject * obj0 = 0 ;
44547 char *kwnames[] = {
44548 (char *) "self", NULL
44549 };
44550
44551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44553 if (SWIG_arg_fail(1)) SWIG_fail;
44554 {
44555 PyThreadState* __tstate = wxPyBeginAllowThreads();
44556 result = (wxWindow *)(arg1)->GetOtherWindow();
44557
44558 wxPyEndAllowThreads(__tstate);
44559 if (PyErr_Occurred()) SWIG_fail;
44560 }
44561 {
44562 resultobj = wxPyMake_wxObject(result, 0);
44563 }
44564 return resultobj;
44565 fail:
44566 return NULL;
44567 }
44568
44569
44570 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44571 PyObject *resultobj;
44572 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44573 wxEdge result;
44574 PyObject * obj0 = 0 ;
44575 char *kwnames[] = {
44576 (char *) "self", NULL
44577 };
44578
44579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44581 if (SWIG_arg_fail(1)) SWIG_fail;
44582 {
44583 PyThreadState* __tstate = wxPyBeginAllowThreads();
44584 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44585
44586 wxPyEndAllowThreads(__tstate);
44587 if (PyErr_Occurred()) SWIG_fail;
44588 }
44589 resultobj = SWIG_From_int((result));
44590 return resultobj;
44591 fail:
44592 return NULL;
44593 }
44594
44595
44596 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44597 PyObject *resultobj;
44598 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44599 wxEdge arg2 ;
44600 PyObject * obj0 = 0 ;
44601 PyObject * obj1 = 0 ;
44602 char *kwnames[] = {
44603 (char *) "self",(char *) "which", NULL
44604 };
44605
44606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44608 if (SWIG_arg_fail(1)) SWIG_fail;
44609 {
44610 arg2 = (wxEdge)(SWIG_As_int(obj1));
44611 if (SWIG_arg_fail(2)) SWIG_fail;
44612 }
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 (arg1)->SetEdge((wxEdge )arg2);
44616
44617 wxPyEndAllowThreads(__tstate);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 }
44620 Py_INCREF(Py_None); resultobj = Py_None;
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj;
44629 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44630 int arg2 ;
44631 PyObject * obj0 = 0 ;
44632 PyObject * obj1 = 0 ;
44633 char *kwnames[] = {
44634 (char *) "self",(char *) "v", NULL
44635 };
44636
44637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",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 = (int)(SWIG_As_int(obj1));
44642 if (SWIG_arg_fail(2)) SWIG_fail;
44643 }
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 (arg1)->SetValue(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_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44659 PyObject *resultobj;
44660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44661 int result;
44662 PyObject * obj0 = 0 ;
44663 char *kwnames[] = {
44664 (char *) "self", NULL
44665 };
44666
44667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44669 if (SWIG_arg_fail(1)) SWIG_fail;
44670 {
44671 PyThreadState* __tstate = wxPyBeginAllowThreads();
44672 result = (int)(arg1)->GetMargin();
44673
44674 wxPyEndAllowThreads(__tstate);
44675 if (PyErr_Occurred()) SWIG_fail;
44676 }
44677 {
44678 resultobj = SWIG_From_int((int)(result));
44679 }
44680 return resultobj;
44681 fail:
44682 return NULL;
44683 }
44684
44685
44686 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44687 PyObject *resultobj;
44688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44689 int arg2 ;
44690 PyObject * obj0 = 0 ;
44691 PyObject * obj1 = 0 ;
44692 char *kwnames[] = {
44693 (char *) "self",(char *) "m", NULL
44694 };
44695
44696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44698 if (SWIG_arg_fail(1)) SWIG_fail;
44699 {
44700 arg2 = (int)(SWIG_As_int(obj1));
44701 if (SWIG_arg_fail(2)) SWIG_fail;
44702 }
44703 {
44704 PyThreadState* __tstate = wxPyBeginAllowThreads();
44705 (arg1)->SetMargin(arg2);
44706
44707 wxPyEndAllowThreads(__tstate);
44708 if (PyErr_Occurred()) SWIG_fail;
44709 }
44710 Py_INCREF(Py_None); resultobj = Py_None;
44711 return resultobj;
44712 fail:
44713 return NULL;
44714 }
44715
44716
44717 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44718 PyObject *resultobj;
44719 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44720 int result;
44721 PyObject * obj0 = 0 ;
44722 char *kwnames[] = {
44723 (char *) "self", NULL
44724 };
44725
44726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44728 if (SWIG_arg_fail(1)) SWIG_fail;
44729 {
44730 PyThreadState* __tstate = wxPyBeginAllowThreads();
44731 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44732
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 {
44737 resultobj = SWIG_From_int((int)(result));
44738 }
44739 return resultobj;
44740 fail:
44741 return NULL;
44742 }
44743
44744
44745 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44746 PyObject *resultobj;
44747 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44748 int result;
44749 PyObject * obj0 = 0 ;
44750 char *kwnames[] = {
44751 (char *) "self", NULL
44752 };
44753
44754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44756 if (SWIG_arg_fail(1)) SWIG_fail;
44757 {
44758 PyThreadState* __tstate = wxPyBeginAllowThreads();
44759 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44760
44761 wxPyEndAllowThreads(__tstate);
44762 if (PyErr_Occurred()) SWIG_fail;
44763 }
44764 {
44765 resultobj = SWIG_From_int((int)(result));
44766 }
44767 return resultobj;
44768 fail:
44769 return NULL;
44770 }
44771
44772
44773 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44774 PyObject *resultobj;
44775 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44776 int result;
44777 PyObject * obj0 = 0 ;
44778 char *kwnames[] = {
44779 (char *) "self", NULL
44780 };
44781
44782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44784 if (SWIG_arg_fail(1)) SWIG_fail;
44785 {
44786 PyThreadState* __tstate = wxPyBeginAllowThreads();
44787 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44788
44789 wxPyEndAllowThreads(__tstate);
44790 if (PyErr_Occurred()) SWIG_fail;
44791 }
44792 {
44793 resultobj = SWIG_From_int((int)(result));
44794 }
44795 return resultobj;
44796 fail:
44797 return NULL;
44798 }
44799
44800
44801 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44802 PyObject *resultobj;
44803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44804 bool result;
44805 PyObject * obj0 = 0 ;
44806 char *kwnames[] = {
44807 (char *) "self", NULL
44808 };
44809
44810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44812 if (SWIG_arg_fail(1)) SWIG_fail;
44813 {
44814 PyThreadState* __tstate = wxPyBeginAllowThreads();
44815 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44816
44817 wxPyEndAllowThreads(__tstate);
44818 if (PyErr_Occurred()) SWIG_fail;
44819 }
44820 {
44821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44822 }
44823 return resultobj;
44824 fail:
44825 return NULL;
44826 }
44827
44828
44829 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44830 PyObject *resultobj;
44831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44832 bool arg2 ;
44833 PyObject * obj0 = 0 ;
44834 PyObject * obj1 = 0 ;
44835 char *kwnames[] = {
44836 (char *) "self",(char *) "d", NULL
44837 };
44838
44839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44841 if (SWIG_arg_fail(1)) SWIG_fail;
44842 {
44843 arg2 = (bool)(SWIG_As_bool(obj1));
44844 if (SWIG_arg_fail(2)) SWIG_fail;
44845 }
44846 {
44847 PyThreadState* __tstate = wxPyBeginAllowThreads();
44848 (arg1)->SetDone(arg2);
44849
44850 wxPyEndAllowThreads(__tstate);
44851 if (PyErr_Occurred()) SWIG_fail;
44852 }
44853 Py_INCREF(Py_None); resultobj = Py_None;
44854 return resultobj;
44855 fail:
44856 return NULL;
44857 }
44858
44859
44860 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44861 PyObject *resultobj;
44862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44863 wxRelationship result;
44864 PyObject * obj0 = 0 ;
44865 char *kwnames[] = {
44866 (char *) "self", NULL
44867 };
44868
44869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44871 if (SWIG_arg_fail(1)) SWIG_fail;
44872 {
44873 PyThreadState* __tstate = wxPyBeginAllowThreads();
44874 result = (wxRelationship)(arg1)->GetRelationship();
44875
44876 wxPyEndAllowThreads(__tstate);
44877 if (PyErr_Occurred()) SWIG_fail;
44878 }
44879 resultobj = SWIG_From_int((result));
44880 return resultobj;
44881 fail:
44882 return NULL;
44883 }
44884
44885
44886 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44887 PyObject *resultobj;
44888 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44889 wxRelationship arg2 ;
44890 PyObject * obj0 = 0 ;
44891 PyObject * obj1 = 0 ;
44892 char *kwnames[] = {
44893 (char *) "self",(char *) "r", NULL
44894 };
44895
44896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44898 if (SWIG_arg_fail(1)) SWIG_fail;
44899 {
44900 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44901 if (SWIG_arg_fail(2)) SWIG_fail;
44902 }
44903 {
44904 PyThreadState* __tstate = wxPyBeginAllowThreads();
44905 (arg1)->SetRelationship((wxRelationship )arg2);
44906
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 Py_INCREF(Py_None); resultobj = Py_None;
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44918 PyObject *resultobj;
44919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44920 wxWindow *arg2 = (wxWindow *) 0 ;
44921 bool result;
44922 PyObject * obj0 = 0 ;
44923 PyObject * obj1 = 0 ;
44924 char *kwnames[] = {
44925 (char *) "self",(char *) "otherW", NULL
44926 };
44927
44928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44930 if (SWIG_arg_fail(1)) SWIG_fail;
44931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44932 if (SWIG_arg_fail(2)) SWIG_fail;
44933 {
44934 PyThreadState* __tstate = wxPyBeginAllowThreads();
44935 result = (bool)(arg1)->ResetIfWin(arg2);
44936
44937 wxPyEndAllowThreads(__tstate);
44938 if (PyErr_Occurred()) SWIG_fail;
44939 }
44940 {
44941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44942 }
44943 return resultobj;
44944 fail:
44945 return NULL;
44946 }
44947
44948
44949 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44950 PyObject *resultobj;
44951 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44952 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44953 wxWindow *arg3 = (wxWindow *) 0 ;
44954 bool result;
44955 PyObject * obj0 = 0 ;
44956 PyObject * obj1 = 0 ;
44957 PyObject * obj2 = 0 ;
44958 char *kwnames[] = {
44959 (char *) "self",(char *) "constraints",(char *) "win", NULL
44960 };
44961
44962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44964 if (SWIG_arg_fail(1)) SWIG_fail;
44965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44966 if (SWIG_arg_fail(2)) SWIG_fail;
44967 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44968 if (SWIG_arg_fail(3)) SWIG_fail;
44969 {
44970 PyThreadState* __tstate = wxPyBeginAllowThreads();
44971 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44972
44973 wxPyEndAllowThreads(__tstate);
44974 if (PyErr_Occurred()) SWIG_fail;
44975 }
44976 {
44977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44978 }
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44986 PyObject *resultobj;
44987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44988 wxEdge arg2 ;
44989 wxWindow *arg3 = (wxWindow *) 0 ;
44990 wxWindow *arg4 = (wxWindow *) 0 ;
44991 int result;
44992 PyObject * obj0 = 0 ;
44993 PyObject * obj1 = 0 ;
44994 PyObject * obj2 = 0 ;
44995 PyObject * obj3 = 0 ;
44996 char *kwnames[] = {
44997 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44998 };
44999
45000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45002 if (SWIG_arg_fail(1)) SWIG_fail;
45003 {
45004 arg2 = (wxEdge)(SWIG_As_int(obj1));
45005 if (SWIG_arg_fail(2)) SWIG_fail;
45006 }
45007 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45008 if (SWIG_arg_fail(3)) SWIG_fail;
45009 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45010 if (SWIG_arg_fail(4)) SWIG_fail;
45011 {
45012 PyThreadState* __tstate = wxPyBeginAllowThreads();
45013 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45014
45015 wxPyEndAllowThreads(__tstate);
45016 if (PyErr_Occurred()) SWIG_fail;
45017 }
45018 {
45019 resultobj = SWIG_From_int((int)(result));
45020 }
45021 return resultobj;
45022 fail:
45023 return NULL;
45024 }
45025
45026
45027 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45028 PyObject *obj;
45029 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45030 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45031 Py_INCREF(obj);
45032 return Py_BuildValue((char *)"");
45033 }
45034 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45035 PyObject *resultobj;
45036 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45037 wxIndividualLayoutConstraint *result;
45038 PyObject * obj0 = 0 ;
45039 char *kwnames[] = {
45040 (char *) "self", NULL
45041 };
45042
45043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45045 if (SWIG_arg_fail(1)) SWIG_fail;
45046 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45047
45048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45049 return resultobj;
45050 fail:
45051 return NULL;
45052 }
45053
45054
45055 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45056 PyObject *resultobj;
45057 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45058 wxIndividualLayoutConstraint *result;
45059 PyObject * obj0 = 0 ;
45060 char *kwnames[] = {
45061 (char *) "self", NULL
45062 };
45063
45064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45066 if (SWIG_arg_fail(1)) SWIG_fail;
45067 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45068
45069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45070 return resultobj;
45071 fail:
45072 return NULL;
45073 }
45074
45075
45076 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45077 PyObject *resultobj;
45078 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45079 wxIndividualLayoutConstraint *result;
45080 PyObject * obj0 = 0 ;
45081 char *kwnames[] = {
45082 (char *) "self", NULL
45083 };
45084
45085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45087 if (SWIG_arg_fail(1)) SWIG_fail;
45088 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45089
45090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45091 return resultobj;
45092 fail:
45093 return NULL;
45094 }
45095
45096
45097 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj;
45099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45100 wxIndividualLayoutConstraint *result;
45101 PyObject * obj0 = 0 ;
45102 char *kwnames[] = {
45103 (char *) "self", NULL
45104 };
45105
45106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45108 if (SWIG_arg_fail(1)) SWIG_fail;
45109 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45110
45111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45112 return resultobj;
45113 fail:
45114 return NULL;
45115 }
45116
45117
45118 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj;
45120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45121 wxIndividualLayoutConstraint *result;
45122 PyObject * obj0 = 0 ;
45123 char *kwnames[] = {
45124 (char *) "self", NULL
45125 };
45126
45127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45129 if (SWIG_arg_fail(1)) SWIG_fail;
45130 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45131
45132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj;
45141 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45142 wxIndividualLayoutConstraint *result;
45143 PyObject * obj0 = 0 ;
45144 char *kwnames[] = {
45145 (char *) "self", NULL
45146 };
45147
45148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45150 if (SWIG_arg_fail(1)) SWIG_fail;
45151 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45152
45153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45154 return resultobj;
45155 fail:
45156 return NULL;
45157 }
45158
45159
45160 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45161 PyObject *resultobj;
45162 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45163 wxIndividualLayoutConstraint *result;
45164 PyObject * obj0 = 0 ;
45165 char *kwnames[] = {
45166 (char *) "self", NULL
45167 };
45168
45169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45171 if (SWIG_arg_fail(1)) SWIG_fail;
45172 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45173
45174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj;
45183 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45184 wxIndividualLayoutConstraint *result;
45185 PyObject * obj0 = 0 ;
45186 char *kwnames[] = {
45187 (char *) "self", NULL
45188 };
45189
45190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45192 if (SWIG_arg_fail(1)) SWIG_fail;
45193 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45194
45195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45196 return resultobj;
45197 fail:
45198 return NULL;
45199 }
45200
45201
45202 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45203 PyObject *resultobj;
45204 wxLayoutConstraints *result;
45205 char *kwnames[] = {
45206 NULL
45207 };
45208
45209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45213
45214 wxPyEndAllowThreads(__tstate);
45215 if (PyErr_Occurred()) SWIG_fail;
45216 }
45217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45218 return resultobj;
45219 fail:
45220 return NULL;
45221 }
45222
45223
45224 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45225 PyObject *resultobj;
45226 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45227 wxWindow *arg2 = (wxWindow *) 0 ;
45228 int *arg3 = (int *) 0 ;
45229 bool result;
45230 int temp3 ;
45231 int res3 = 0 ;
45232 PyObject * obj0 = 0 ;
45233 PyObject * obj1 = 0 ;
45234 char *kwnames[] = {
45235 (char *) "self",(char *) "win", NULL
45236 };
45237
45238 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45241 if (SWIG_arg_fail(1)) SWIG_fail;
45242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45243 if (SWIG_arg_fail(2)) SWIG_fail;
45244 {
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45247
45248 wxPyEndAllowThreads(__tstate);
45249 if (PyErr_Occurred()) SWIG_fail;
45250 }
45251 {
45252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45253 }
45254 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45255 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45256 return resultobj;
45257 fail:
45258 return NULL;
45259 }
45260
45261
45262 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45263 PyObject *resultobj;
45264 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45265 bool result;
45266 PyObject * obj0 = 0 ;
45267 char *kwnames[] = {
45268 (char *) "self", NULL
45269 };
45270
45271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45273 if (SWIG_arg_fail(1)) SWIG_fail;
45274 {
45275 PyThreadState* __tstate = wxPyBeginAllowThreads();
45276 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45277
45278 wxPyEndAllowThreads(__tstate);
45279 if (PyErr_Occurred()) SWIG_fail;
45280 }
45281 {
45282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45283 }
45284 return resultobj;
45285 fail:
45286 return NULL;
45287 }
45288
45289
45290 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45291 PyObject *obj;
45292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45293 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45294 Py_INCREF(obj);
45295 return Py_BuildValue((char *)"");
45296 }
45297 static PyMethodDef SwigMethods[] = {
45298 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45299 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45300 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45303 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45324 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45337 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45352 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45406 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45434 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45453 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45455 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45463 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45464 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45476 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45488 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45492 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45498 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45508 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45518 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45525 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45605 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45607 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45609 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45611 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45613 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45615 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45617 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45619 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45621 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45623 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45625 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45627 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45629 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45643 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45661 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45664 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45667 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45679 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45684 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45690 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45696 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45759 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45766 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45802 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45812 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45818 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45820 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45822 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45825 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45829 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45832 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45835 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45837 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45842 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45850 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45854 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45857 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45859 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45863 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45880 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45882 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45885 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45887 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45891 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45895 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45906 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45909 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45912 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45916 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45923 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45928 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45933 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45937 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45982 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46002 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46009 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46013 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46023 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46195 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46235 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46250 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46253 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46308 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46335 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46379 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46387 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46406 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46407 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46444 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46474 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46477 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46481 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46484 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46494 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46506 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46518 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46528 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46538 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46552 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46559 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46560 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46561 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46562 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46563 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46568 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46595 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46607 { NULL, NULL, 0, NULL }
46608 };
46609
46610
46611 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46612
46613 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46614 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46615 }
46616 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46617 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46618 }
46619 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46620 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46621 }
46622 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46623 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46624 }
46625 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46626 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46627 }
46628 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46629 return (void *)((wxSizer *) ((wxGridSizer *) x));
46630 }
46631 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46632 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46633 }
46634 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46635 return (void *)((wxSizer *) ((wxPySizer *) x));
46636 }
46637 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46638 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46639 }
46640 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46641 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46642 }
46643 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46644 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46645 }
46646 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46647 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46648 }
46649 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46650 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46651 }
46652 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46653 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46654 }
46655 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46656 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46657 }
46658 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46659 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46660 }
46661 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46662 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46663 }
46664 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46665 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46666 }
46667 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46668 return (void *)((wxEvent *) ((wxPyEvent *) x));
46669 }
46670 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46671 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46672 }
46673 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46674 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46675 }
46676 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46677 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46678 }
46679 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46680 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46681 }
46682 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46683 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46684 }
46685 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46686 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46687 }
46688 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46689 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46690 }
46691 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46692 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46693 }
46694 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46695 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46696 }
46697 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46698 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46699 }
46700 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46701 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46702 }
46703 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46704 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46705 }
46706 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46707 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46708 }
46709 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46710 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46711 }
46712 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46713 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46714 }
46715 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46716 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46717 }
46718 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46719 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46720 }
46721 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46722 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46723 }
46724 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46725 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46726 }
46727 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46729 }
46730 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) ((wxShowEvent *) x));
46732 }
46733 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46735 }
46736 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46737 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46738 }
46739 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46740 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46741 }
46742 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46743 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46744 }
46745 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46746 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46747 }
46748 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46749 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46750 }
46751 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46752 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46753 }
46754 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46755 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46756 }
46757 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46758 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46759 }
46760 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46761 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46762 }
46763 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46764 return (void *)((wxControl *) ((wxControlWithItems *) x));
46765 }
46766 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46767 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46768 }
46769 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46770 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46771 }
46772 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46773 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46774 }
46775 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46776 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46777 }
46778 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46779 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46780 }
46781 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46782 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46783 }
46784 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46785 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46786 }
46787 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46788 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46789 }
46790 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46791 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46792 }
46793 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46794 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46795 }
46796 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46797 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46798 }
46799 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46800 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46801 }
46802 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46803 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46804 }
46805 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46806 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46807 }
46808 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46809 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46810 }
46811 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46812 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46813 }
46814 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46815 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46816 }
46817 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46818 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46819 }
46820 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46821 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46822 }
46823 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46824 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46825 }
46826 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46827 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46828 }
46829 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46830 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46831 }
46832 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46833 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46834 }
46835 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46836 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46837 }
46838 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46839 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46840 }
46841 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46842 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46843 }
46844 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46845 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46846 }
46847 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46848 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46849 }
46850 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46851 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46852 }
46853 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46854 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46855 }
46856 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46857 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46858 }
46859 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46860 return (void *)((wxObject *) ((wxSizerItem *) x));
46861 }
46862 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46863 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46864 }
46865 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46866 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46867 }
46868 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46869 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46870 }
46871 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46872 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46873 }
46874 static void *_p_wxSizerTo_p_wxObject(void *x) {
46875 return (void *)((wxObject *) ((wxSizer *) x));
46876 }
46877 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46878 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46879 }
46880 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46881 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46882 }
46883 static void *_p_wxEventTo_p_wxObject(void *x) {
46884 return (void *)((wxObject *) ((wxEvent *) x));
46885 }
46886 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46887 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46888 }
46889 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46890 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46891 }
46892 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46893 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46894 }
46895 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46896 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46897 }
46898 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46899 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46900 }
46901 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46902 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46903 }
46904 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46905 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46906 }
46907 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46908 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46909 }
46910 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46911 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46912 }
46913 static void *_p_wxControlTo_p_wxObject(void *x) {
46914 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46915 }
46916 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46917 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46918 }
46919 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46920 return (void *)((wxObject *) ((wxFSFile *) x));
46921 }
46922 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46923 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46924 }
46925 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46926 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46927 }
46928 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46929 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46930 }
46931 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46932 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46933 }
46934 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46935 return (void *)((wxObject *) ((wxMenuItem *) x));
46936 }
46937 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46939 }
46940 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46942 }
46943 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46945 }
46946 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46948 }
46949 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46951 }
46952 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46954 }
46955 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46957 }
46958 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46960 }
46961 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46963 }
46964 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46966 }
46967 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46969 }
46970 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46972 }
46973 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46975 }
46976 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46978 }
46979 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46981 }
46982 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46984 }
46985 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46987 }
46988 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46990 }
46991 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46993 }
46994 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) ((wxImageHandler *) x));
46996 }
46997 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46999 }
47000 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) ((wxEvtHandler *) x));
47002 }
47003 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47005 }
47006 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47008 }
47009 static void *_p_wxImageTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) ((wxImage *) x));
47011 }
47012 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47014 }
47015 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47017 }
47018 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47020 }
47021 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47023 }
47024 static void *_p_wxWindowTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47026 }
47027 static void *_p_wxMenuTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47029 }
47030 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47032 }
47033 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) ((wxFileSystem *) x));
47035 }
47036 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47038 }
47039 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47041 }
47042 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47044 }
47045 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47047 }
47048 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47050 }
47051 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47053 }
47054 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47056 }
47057 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47059 }
47060 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47062 }
47063 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47065 }
47066 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47068 }
47069 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47070 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47071 }
47072 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47073 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47074 }
47075 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47076 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47077 }
47078 static void *_p_wxControlTo_p_wxWindow(void *x) {
47079 return (void *)((wxWindow *) ((wxControl *) x));
47080 }
47081 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47082 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47083 }
47084 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47085 return (void *)((wxWindow *) ((wxMenuBar *) x));
47086 }
47087 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47088 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47089 }
47090 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47091 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47092 }
47093 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47094 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47095 }
47096 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47097 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47098 }
47099 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47100 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47101 }
47102 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47103 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47104 }
47105 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47106 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47107 }
47108 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47109 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47110 }
47111 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47112 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47113 }
47114 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47115 return (void *)((wxValidator *) ((wxPyValidator *) x));
47116 }
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245
47246 static swig_type_info *swig_types_initial[] = {
47247 _swigt__p_wxLayoutConstraints,
47248 _swigt__p_wxRealPoint,
47249 _swigt__p_wxSizerItem,
47250 _swigt__p_wxGBSizerItem,
47251 _swigt__p_wxScrollEvent,
47252 _swigt__p_wxEventLoop,
47253 _swigt__p_wxIndividualLayoutConstraint,
47254 _swigt__p_wxSizer,
47255 _swigt__p_wxBoxSizer,
47256 _swigt__p_wxStaticBoxSizer,
47257 _swigt__p_wxGridBagSizer,
47258 _swigt__p_wxAcceleratorEntry,
47259 _swigt__p_wxUpdateUIEvent,
47260 _swigt__p_wxEvent,
47261 _swigt__p_buffer,
47262 _swigt__p_wxMenu,
47263 _swigt__p_wxGridSizer,
47264 _swigt__p_wxFlexGridSizer,
47265 _swigt__p_wxInitDialogEvent,
47266 _swigt__p_wxItemContainer,
47267 _swigt__p_wxNcPaintEvent,
47268 _swigt__p_wxPaintEvent,
47269 _swigt__p_wxSysColourChangedEvent,
47270 _swigt__p_wxMouseCaptureChangedEvent,
47271 _swigt__p_wxDisplayChangedEvent,
47272 _swigt__p_wxPaletteChangedEvent,
47273 _swigt__p_wxControl,
47274 _swigt__p_wxFont,
47275 _swigt__p_wxMenuBarBase,
47276 _swigt__p_wxSetCursorEvent,
47277 _swigt__p_wxFSFile,
47278 _swigt__p_wxCaret,
47279 _swigt__ptrdiff_t,
47280 _swigt__std__ptrdiff_t,
47281 _swigt__p_wxRegion,
47282 _swigt__p_wxPoint2D,
47283 _swigt__p_int,
47284 _swigt__p_wxSize,
47285 _swigt__p_wxDC,
47286 _swigt__p_wxPySizer,
47287 _swigt__p_wxVisualAttributes,
47288 _swigt__p_wxNotifyEvent,
47289 _swigt__p_wxPyEvent,
47290 _swigt__p_wxPropagationDisabler,
47291 _swigt__p_form_ops_t,
47292 _swigt__p_wxAppTraits,
47293 _swigt__p_wxArrayString,
47294 _swigt__p_wxShowEvent,
47295 _swigt__p_wxToolTip,
47296 _swigt__p_wxMoveEvent,
47297 _swigt__p_wxSizeEvent,
47298 _swigt__p_wxActivateEvent,
47299 _swigt__p_wxIconizeEvent,
47300 _swigt__p_wxMaximizeEvent,
47301 _swigt__p_wxQueryNewPaletteEvent,
47302 _swigt__p_wxWindowCreateEvent,
47303 _swigt__p_wxIdleEvent,
47304 _swigt__p_wxDateEvent,
47305 _swigt__p_wxMenuItem,
47306 _swigt__p_wxStaticBox,
47307 _swigt__p_long,
47308 _swigt__p_wxDuplexMode,
47309 _swigt__p_wxTIFFHandler,
47310 _swigt__p_wxXPMHandler,
47311 _swigt__p_wxPNMHandler,
47312 _swigt__p_wxJPEGHandler,
47313 _swigt__p_wxPCXHandler,
47314 _swigt__p_wxGIFHandler,
47315 _swigt__p_wxPNGHandler,
47316 _swigt__p_wxANIHandler,
47317 _swigt__p_wxMemoryFSHandler,
47318 _swigt__p_wxZipFSHandler,
47319 _swigt__p_wxInternetFSHandler,
47320 _swigt__p_wxPyFileSystemHandler,
47321 _swigt__p_wxEvtHandler,
47322 _swigt__p_wxCURHandler,
47323 _swigt__p_wxICOHandler,
47324 _swigt__p_wxBMPHandler,
47325 _swigt__p_wxImageHandler,
47326 _swigt__p_wxFileSystemHandler,
47327 _swigt__p_wxRect,
47328 _swigt__p_wxButton,
47329 _swigt__p_wxGBSpan,
47330 _swigt__p_wxPropagateOnce,
47331 _swigt__p_wxAcceleratorTable,
47332 _swigt__p_wxStdDialogButtonSizer,
47333 _swigt__p_char,
47334 _swigt__p_wxGBPosition,
47335 _swigt__p_wxImage,
47336 _swigt__p_wxFrame,
47337 _swigt__p_wxScrollWinEvent,
47338 _swigt__p_wxPaperSize,
47339 _swigt__p_wxImageHistogram,
47340 _swigt__p_wxPoint,
47341 _swigt__p_wxCursor,
47342 _swigt__p_wxObject,
47343 _swigt__p_wxInputStream,
47344 _swigt__p_wxOutputStream,
47345 _swigt__p_wxPyInputStream,
47346 _swigt__p_wxDateTime,
47347 _swigt__p_wxKeyEvent,
47348 _swigt__p_wxNavigationKeyEvent,
47349 _swigt__p_wxWindowDestroyEvent,
47350 _swigt__p_unsigned_long,
47351 _swigt__p_wxWindow,
47352 _swigt__p_wxMenuBar,
47353 _swigt__p_wxFileSystem,
47354 _swigt__p_wxBitmap,
47355 _swigt__unsigned_int,
47356 _swigt__p_unsigned_int,
47357 _swigt__p_wxMenuEvent,
47358 _swigt__p_wxContextMenuEvent,
47359 _swigt__p_unsigned_char,
47360 _swigt__p_wxEraseEvent,
47361 _swigt__p_wxMouseEvent,
47362 _swigt__p_wxCloseEvent,
47363 _swigt__p_wxPyApp,
47364 _swigt__p_wxCommandEvent,
47365 _swigt__p_wxPyCommandEvent,
47366 _swigt__p_wxPyDropTarget,
47367 _swigt__p_wxQuantize,
47368 _swigt__p_wxFocusEvent,
47369 _swigt__p_wxChildFocusEvent,
47370 _swigt__p_wxDropFilesEvent,
47371 _swigt__p_wxControlWithItems,
47372 _swigt__p_wxColour,
47373 _swigt__p_wxValidator,
47374 _swigt__p_wxPyValidator,
47375 0
47376 };
47377
47378
47379 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47380
47381 static swig_const_info swig_const_table[] = {
47382 {0, 0, 0, 0.0, 0, 0}};
47383
47384 #ifdef __cplusplus
47385 }
47386 #endif
47387
47388
47389 #ifdef __cplusplus
47390 extern "C" {
47391 #endif
47392
47393 /* Python-specific SWIG API */
47394 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47395 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47396 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47397
47398 /* -----------------------------------------------------------------------------
47399 * global variable support code.
47400 * ----------------------------------------------------------------------------- */
47401
47402 typedef struct swig_globalvar {
47403 char *name; /* Name of global variable */
47404 PyObject *(*get_attr)(); /* Return the current value */
47405 int (*set_attr)(PyObject *); /* Set the value */
47406 struct swig_globalvar *next;
47407 } swig_globalvar;
47408
47409 typedef struct swig_varlinkobject {
47410 PyObject_HEAD
47411 swig_globalvar *vars;
47412 } swig_varlinkobject;
47413
47414 static PyObject *
47415 swig_varlink_repr(swig_varlinkobject *v) {
47416 v = v;
47417 return PyString_FromString("<Swig global variables>");
47418 }
47419
47420 static int
47421 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47422 swig_globalvar *var;
47423 flags = flags;
47424 fprintf(fp,"Swig global variables { ");
47425 for (var = v->vars; var; var=var->next) {
47426 fprintf(fp,"%s", var->name);
47427 if (var->next) fprintf(fp,", ");
47428 }
47429 fprintf(fp," }\n");
47430 return 0;
47431 }
47432
47433 static PyObject *
47434 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47435 swig_globalvar *var = v->vars;
47436 while (var) {
47437 if (strcmp(var->name,n) == 0) {
47438 return (*var->get_attr)();
47439 }
47440 var = var->next;
47441 }
47442 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47443 return NULL;
47444 }
47445
47446 static int
47447 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47448 swig_globalvar *var = v->vars;
47449 while (var) {
47450 if (strcmp(var->name,n) == 0) {
47451 return (*var->set_attr)(p);
47452 }
47453 var = var->next;
47454 }
47455 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47456 return 1;
47457 }
47458
47459 static PyTypeObject varlinktype = {
47460 PyObject_HEAD_INIT(0)
47461 0, /* Number of items in variable part (ob_size) */
47462 (char *)"swigvarlink", /* Type name (tp_name) */
47463 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47464 0, /* Itemsize (tp_itemsize) */
47465 0, /* Deallocator (tp_dealloc) */
47466 (printfunc) swig_varlink_print, /* Print (tp_print) */
47467 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47468 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47469 0, /* tp_compare */
47470 (reprfunc) swig_varlink_repr, /* tp_repr */
47471 0, /* tp_as_number */
47472 0, /* tp_as_sequence */
47473 0, /* tp_as_mapping */
47474 0, /* tp_hash */
47475 0, /* tp_call */
47476 0, /* tp_str */
47477 0, /* tp_getattro */
47478 0, /* tp_setattro */
47479 0, /* tp_as_buffer */
47480 0, /* tp_flags */
47481 0, /* tp_doc */
47482 #if PY_VERSION_HEX >= 0x02000000
47483 0, /* tp_traverse */
47484 0, /* tp_clear */
47485 #endif
47486 #if PY_VERSION_HEX >= 0x02010000
47487 0, /* tp_richcompare */
47488 0, /* tp_weaklistoffset */
47489 #endif
47490 #if PY_VERSION_HEX >= 0x02020000
47491 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47492 #endif
47493 #if PY_VERSION_HEX >= 0x02030000
47494 0, /* tp_del */
47495 #endif
47496 #ifdef COUNT_ALLOCS
47497 0,0,0,0 /* tp_alloc -> tp_next */
47498 #endif
47499 };
47500
47501 /* Create a variable linking object for use later */
47502 static PyObject *
47503 SWIG_Python_newvarlink(void) {
47504 swig_varlinkobject *result = 0;
47505 result = PyMem_NEW(swig_varlinkobject,1);
47506 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47507 result->ob_type = &varlinktype;
47508 result->vars = 0;
47509 result->ob_refcnt = 0;
47510 Py_XINCREF((PyObject *) result);
47511 return ((PyObject*) result);
47512 }
47513
47514 static void
47515 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47516 swig_varlinkobject *v;
47517 swig_globalvar *gv;
47518 v= (swig_varlinkobject *) p;
47519 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47520 gv->name = (char *) malloc(strlen(name)+1);
47521 strcpy(gv->name,name);
47522 gv->get_attr = get_attr;
47523 gv->set_attr = set_attr;
47524 gv->next = v->vars;
47525 v->vars = gv;
47526 }
47527
47528 /* -----------------------------------------------------------------------------
47529 * constants/methods manipulation
47530 * ----------------------------------------------------------------------------- */
47531
47532 /* Install Constants */
47533 static void
47534 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47535 PyObject *obj = 0;
47536 size_t i;
47537 for (i = 0; constants[i].type; i++) {
47538 switch(constants[i].type) {
47539 case SWIG_PY_INT:
47540 obj = PyInt_FromLong(constants[i].lvalue);
47541 break;
47542 case SWIG_PY_FLOAT:
47543 obj = PyFloat_FromDouble(constants[i].dvalue);
47544 break;
47545 case SWIG_PY_STRING:
47546 if (constants[i].pvalue) {
47547 obj = PyString_FromString((char *) constants[i].pvalue);
47548 } else {
47549 Py_INCREF(Py_None);
47550 obj = Py_None;
47551 }
47552 break;
47553 case SWIG_PY_POINTER:
47554 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47555 break;
47556 case SWIG_PY_BINARY:
47557 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47558 break;
47559 default:
47560 obj = 0;
47561 break;
47562 }
47563 if (obj) {
47564 PyDict_SetItemString(d,constants[i].name,obj);
47565 Py_DECREF(obj);
47566 }
47567 }
47568 }
47569
47570 /* -----------------------------------------------------------------------------*/
47571 /* Fix SwigMethods to carry the callback ptrs when needed */
47572 /* -----------------------------------------------------------------------------*/
47573
47574 static void
47575 SWIG_Python_FixMethods(PyMethodDef *methods,
47576 swig_const_info *const_table,
47577 swig_type_info **types,
47578 swig_type_info **types_initial) {
47579 size_t i;
47580 for (i = 0; methods[i].ml_name; ++i) {
47581 char *c = methods[i].ml_doc;
47582 if (c && (c = strstr(c, "swig_ptr: "))) {
47583 int j;
47584 swig_const_info *ci = 0;
47585 char *name = c + 10;
47586 for (j = 0; const_table[j].type; j++) {
47587 if (strncmp(const_table[j].name, name,
47588 strlen(const_table[j].name)) == 0) {
47589 ci = &(const_table[j]);
47590 break;
47591 }
47592 }
47593 if (ci) {
47594 size_t shift = (ci->ptype) - types;
47595 swig_type_info *ty = types_initial[shift];
47596 size_t ldoc = (c - methods[i].ml_doc);
47597 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47598 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47599 char *buff = ndoc;
47600 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47601 strncpy(buff, methods[i].ml_doc, ldoc);
47602 buff += ldoc;
47603 strncpy(buff, "swig_ptr: ", 10);
47604 buff += 10;
47605 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47606 methods[i].ml_doc = ndoc;
47607 }
47608 }
47609 }
47610 }
47611
47612 /* -----------------------------------------------------------------------------*
47613 * Initialize type list
47614 * -----------------------------------------------------------------------------*/
47615
47616 #if PY_MAJOR_VERSION < 2
47617 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47618 is copied out of Python/modsupport.c in python version 2.3.4 */
47619 static int
47620 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47621 {
47622 PyObject *dict;
47623 if (!PyModule_Check(m)) {
47624 PyErr_SetString(PyExc_TypeError,
47625 "PyModule_AddObject() needs module as first arg");
47626 return -1;
47627 }
47628 if (!o) {
47629 PyErr_SetString(PyExc_TypeError,
47630 "PyModule_AddObject() needs non-NULL value");
47631 return -1;
47632 }
47633
47634 dict = PyModule_GetDict(m);
47635 if (dict == NULL) {
47636 /* Internal error -- modules must have a dict! */
47637 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47638 PyModule_GetName(m));
47639 return -1;
47640 }
47641 if (PyDict_SetItemString(dict, name, o))
47642 return -1;
47643 Py_DECREF(o);
47644 return 0;
47645 }
47646 #endif
47647
47648 static swig_type_info **
47649 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47650 static PyMethodDef swig_empty_runtime_method_table[] = {
47651 {
47652 NULL, NULL, 0, NULL
47653 }
47654 };/* Sentinel */
47655
47656 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47657 swig_empty_runtime_method_table);
47658 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47659 if (pointer && module) {
47660 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47661 }
47662 return type_list_handle;
47663 }
47664
47665 static swig_type_info **
47666 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47667 swig_type_info **type_pointer;
47668
47669 /* first check if module already created */
47670 type_pointer = SWIG_Python_GetTypeListHandle();
47671 if (type_pointer) {
47672 return type_pointer;
47673 } else {
47674 /* create a new module and variable */
47675 return SWIG_Python_SetTypeListHandle(type_list_handle);
47676 }
47677 }
47678
47679 #ifdef __cplusplus
47680 }
47681 #endif
47682
47683 /* -----------------------------------------------------------------------------*
47684 * Partial Init method
47685 * -----------------------------------------------------------------------------*/
47686
47687 #ifdef SWIG_LINK_RUNTIME
47688 #ifdef __cplusplus
47689 extern "C"
47690 #endif
47691 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47692 #endif
47693
47694 #ifdef __cplusplus
47695 extern "C"
47696 #endif
47697 SWIGEXPORT(void) SWIG_init(void) {
47698 static PyObject *SWIG_globals = 0;
47699 static int typeinit = 0;
47700 PyObject *m, *d;
47701 int i;
47702 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47703
47704 /* Fix SwigMethods to carry the callback ptrs when needed */
47705 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47706
47707 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47708 d = PyModule_GetDict(m);
47709
47710 if (!typeinit) {
47711 #ifdef SWIG_LINK_RUNTIME
47712 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47713 #else
47714 # ifndef SWIG_STATIC_RUNTIME
47715 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47716 # endif
47717 #endif
47718 for (i = 0; swig_types_initial[i]; i++) {
47719 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47720 }
47721 typeinit = 1;
47722 }
47723 SWIG_InstallConstants(d,swig_const_table);
47724
47725
47726 #ifndef wxPyUSE_EXPORT
47727 // Make our API structure a CObject so other modules can import it
47728 // from this module.
47729 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47730 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47731 Py_XDECREF(cobj);
47732 #endif
47733
47734 {
47735 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49398 }
49399 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49400 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49401 {
49402 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49553 }
49554 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49555 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49556 {
49557 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49564 }
49565
49566 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49567
49568
49569 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49570
49571 {
49572 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49579 }
49580 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49581 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49582 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49583 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49584 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49585 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49586 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49587 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49588 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49589 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49590 {
49591 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49595 }
49596 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49597 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49598 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49599 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49600 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49601 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49602 {
49603 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49649 }
49650 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49651 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49652 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49653 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49654 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49655 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49656 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49657 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49658 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49659 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49660 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49661 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49662 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49663 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49664 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49665 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49666 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49667 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49668 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49669 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49670 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49671 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49672 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49673 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49674 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49675 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49676 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49677 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49678 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49679 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49680 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49681 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49682 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49683 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49684 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49685 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49686 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49687 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49688 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49689 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49690 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49691 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49692 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49693 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49694 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49695 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49696 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49697 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49698 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49699 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49700 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49701 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49702 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49703 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49704 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49705 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49706 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49707 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49708 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49709 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49710 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49711 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49712 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49713 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49714 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49715 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49716 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49717 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49718 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49719 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49720 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49721 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49722 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49723 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49724 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49725 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49726 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49727 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49728 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49729 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49730 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49731 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49732 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49733 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49734 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49735 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49736 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49737 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49738 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49739 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49740 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49741 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49742 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49743 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49744 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49745 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49746 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49747 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49748 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49749 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49750 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49751 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49752 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49753 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49754 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49755 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49756 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49757 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49758 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49759 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49760 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49761 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49762 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49763 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49764 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49765 {
49766 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49803 }
49804 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49805 {
49806 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49822 }
49823 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49824 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49825 {
49826 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49839 }
49840 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49841 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49842 {
49843 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49850 }
49851 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49852 {
49853 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49908 }
49909
49910 // Initialize threading, some globals and such
49911 __wxPyPreStart(d);
49912
49913
49914 // Although these are defined in __version__ they need to be here too so
49915 // that an assert can be done to ensure that the wxPython and the wxWindows
49916 // versions match.
49917 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49918 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49919 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49920
49921 }
49922
wxWidgets (Impactor)