]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
disable an apparently harmless VC++ warning about /EHa being required with _set_se_tr...
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxButton swig_types[79]
1421 #define SWIGTYPE_p_wxGBSpan swig_types[80]
1422 #define SWIGTYPE_p_wxPropagateOnce swig_types[81]
1423 #define SWIGTYPE_p_wxAcceleratorTable swig_types[82]
1424 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[83]
1425 #define SWIGTYPE_p_char swig_types[84]
1426 #define SWIGTYPE_p_wxGBPosition swig_types[85]
1427 #define SWIGTYPE_p_wxImage swig_types[86]
1428 #define SWIGTYPE_p_wxFrame swig_types[87]
1429 #define SWIGTYPE_p_wxScrollWinEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPaperSize swig_types[89]
1431 #define SWIGTYPE_p_wxImageHistogram swig_types[90]
1432 #define SWIGTYPE_p_wxPoint swig_types[91]
1433 #define SWIGTYPE_p_wxCursor swig_types[92]
1434 #define SWIGTYPE_p_wxObject swig_types[93]
1435 #define SWIGTYPE_p_wxInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxOutputStream swig_types[95]
1437 #define SWIGTYPE_p_wxPyInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxDateTime swig_types[97]
1439 #define SWIGTYPE_p_wxKeyEvent swig_types[98]
1440 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
1442 #define SWIGTYPE_p_unsigned_long swig_types[101]
1443 #define SWIGTYPE_p_wxWindow swig_types[102]
1444 #define SWIGTYPE_p_wxMenuBar swig_types[103]
1445 #define SWIGTYPE_p_wxFileSystem swig_types[104]
1446 #define SWIGTYPE_p_wxBitmap swig_types[105]
1447 #define SWIGTYPE_unsigned_int swig_types[106]
1448 #define SWIGTYPE_p_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_wxMenuEvent swig_types[108]
1450 #define SWIGTYPE_p_wxContextMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_unsigned_char swig_types[110]
1452 #define SWIGTYPE_p_wxEraseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxMouseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxCloseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyApp swig_types[114]
1456 #define SWIGTYPE_p_wxCommandEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyDropTarget swig_types[117]
1459 #define SWIGTYPE_p_wxQuantize swig_types[118]
1460 #define SWIGTYPE_p_wxChildFocusEvent swig_types[119]
1461 #define SWIGTYPE_p_wxFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxDropFilesEvent swig_types[121]
1463 #define SWIGTYPE_p_wxControlWithItems swig_types[122]
1464 #define SWIGTYPE_p_wxColour swig_types[123]
1465 #define SWIGTYPE_p_wxValidator swig_types[124]
1466 #define SWIGTYPE_p_wxPyValidator swig_types[125]
1467 static swig_type_info *swig_types[127];
1468
1469 /* -------- TYPES TABLE (END) -------- */
1470
1471
1472 /*-----------------------------------------------
1473 @(target):= _core_.so
1474 ------------------------------------------------*/
1475 #define SWIG_init init_core_
1476
1477 #define SWIG_name "_core_"
1478
1479 #include "wx/wxPython/wxPython_int.h"
1480 #include "wx/wxPython/pyclasses.h"
1481
1482
1483 #ifndef wxPyUSE_EXPORT
1484 // Helper functions for dealing with SWIG objects and such. These are
1485 // located here so they know about the SWIG types and functions declared
1486 // in the wrapper code.
1487
1488 #include <wx/hashmap.h>
1489 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1490
1491
1492 // Maintains a hashmap of className to swig_type_info pointers. Given the
1493 // name of a class either looks up the type info in the cache, or scans the
1494 // SWIG tables for it.
1495 extern PyObject* wxPyPtrTypeMap;
1496 static
1497 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1498
1499 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1500
1501 if (typeInfoCache == NULL)
1502 typeInfoCache = new wxPyTypeInfoHashMap;
1503
1504 wxString name(className);
1505 swig_type_info* swigType = (*typeInfoCache)[name];
1506
1507 if (! swigType) {
1508 // it wasn't in the cache, so look it up from SWIG
1509 name.Append(wxT(" *"));
1510 swigType = SWIG_TypeQuery(name.mb_str());
1511
1512 // if it still wasn't found, try looking for a mapped name
1513 if (!swigType) {
1514 PyObject* item;
1515 name = className;
1516
1517 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1518 (char*)(const char*)name.mbc_str())) != NULL) {
1519 name = wxString(PyString_AsString(item), *wxConvCurrent);
1520 name.Append(wxT(" *"));
1521 swigType = SWIG_TypeQuery(name.mb_str());
1522 }
1523 }
1524 if (swigType) {
1525 // and add it to the map if found
1526 (*typeInfoCache)[className] = swigType;
1527 }
1528 }
1529 return swigType;
1530 }
1531
1532
1533 // Check if a class name is a type known to SWIG
1534 bool wxPyCheckSwigType(const wxChar* className) {
1535
1536 swig_type_info* swigType = wxPyFindSwigType(className);
1537 return swigType != NULL;
1538 }
1539
1540
1541 // Given a pointer to a C++ object and a class name, construct a Python proxy
1542 // object for it.
1543 PyObject* wxPyConstructObject(void* ptr,
1544 const wxChar* className,
1545 int setThisOwn) {
1546
1547 swig_type_info* swigType = wxPyFindSwigType(className);
1548 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1549
1550 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1551 }
1552
1553
1554 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1555 // Ensures that the proxy object is of the specified (or derived) type. If
1556 // not able to perform the conversion then a Python exception is set and the
1557 // error should be handled properly in the caller. Returns True on success.
1558 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1559 const wxChar* className) {
1560
1561 swig_type_info* swigType = wxPyFindSwigType(className);
1562 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1563
1564 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1565 }
1566
1567
1568 // Make a SWIGified pointer object suitable for a .this attribute
1569 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1570
1571 PyObject* robj = NULL;
1572
1573 swig_type_info* swigType = wxPyFindSwigType(className);
1574 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1575
1576 #ifdef SWIG_COBJECT_TYPES
1577 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1578 #else
1579 {
1580 char result[1024];
1581 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1582 PyString_FromString(result) : 0;
1583 }
1584 #endif
1585
1586 return robj;
1587 }
1588
1589
1590
1591
1592 // Export a C API in a struct. Other modules will be able to load this from
1593 // the wx._core_ module and will then have safe access to these functions,
1594 // even if they are located in another shared library.
1595 static wxPyCoreAPI API = {
1596
1597 wxPyCheckSwigType,
1598 wxPyConstructObject,
1599 wxPyConvertSwigPtr,
1600 wxPyMakeSwigPtr,
1601
1602 wxPyBeginAllowThreads,
1603 wxPyEndAllowThreads,
1604 wxPyBeginBlockThreads,
1605 wxPyEndBlockThreads,
1606
1607 wxPy_ConvertList,
1608
1609 wxString_in_helper,
1610 Py2wxString,
1611 wx2PyString,
1612
1613 byte_LIST_helper,
1614 int_LIST_helper,
1615 long_LIST_helper,
1616 string_LIST_helper,
1617 wxPoint_LIST_helper,
1618 wxBitmap_LIST_helper,
1619 wxString_LIST_helper,
1620 wxAcceleratorEntry_LIST_helper,
1621
1622 wxSize_helper,
1623 wxPoint_helper,
1624 wxRealPoint_helper,
1625 wxRect_helper,
1626 wxColour_helper,
1627 wxPoint2D_helper,
1628
1629 wxPySimple_typecheck,
1630 wxColour_typecheck,
1631
1632 wxPyCBH_setCallbackInfo,
1633 wxPyCBH_findCallback,
1634 wxPyCBH_callCallback,
1635 wxPyCBH_callCallbackObj,
1636 wxPyCBH_delete,
1637
1638 wxPyMake_wxObject,
1639 wxPyMake_wxSizer,
1640 wxPyPtrTypeMap_Add,
1641 wxPy2int_seq_helper,
1642 wxPy4int_seq_helper,
1643 wxArrayString2PyList_helper,
1644 wxArrayInt2PyList_helper,
1645
1646 wxPyClientData_dtor,
1647 wxPyUserData_dtor,
1648 wxPyOORClientData_dtor,
1649
1650 wxPyCBInputStream_create,
1651
1652 wxPyInstance_Check,
1653 wxPySwigInstance_Check,
1654
1655 wxPyCheckForApp
1656
1657 };
1658
1659 #endif
1660
1661
1662 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1663 #define SWIG_From_int PyInt_FromLong
1664 /*@@*/
1665
1666
1667 #if ! wxUSE_HOTKEY
1668 enum wxHotkeyModifier
1669 {
1670 wxMOD_NONE = 0,
1671 wxMOD_ALT = 1,
1672 wxMOD_CONTROL = 2,
1673 wxMOD_SHIFT = 4,
1674 wxMOD_WIN = 8
1675 };
1676 #define wxEVT_HOTKEY 9999
1677 #endif
1678
1679 static const wxString wxPyEmptyString(wxEmptyString);
1680 static wxString wxObject_GetClassName(wxObject *self){
1681 return self->GetClassInfo()->GetClassName();
1682 }
1683 static void wxObject_Destroy(wxObject *self){
1684 delete self;
1685 }
1686
1687 #ifndef __WXMAC__
1688 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1689 #endif
1690
1691
1692 #include <limits.h>
1693
1694
1695 SWIGINTERN int
1696 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1697 const char *errmsg)
1698 {
1699 if (value < min_value) {
1700 if (errmsg) {
1701 PyErr_Format(PyExc_OverflowError,
1702 "value %ld is less than '%s' minimum %ld",
1703 value, errmsg, min_value);
1704 }
1705 return 0;
1706 } else if (value > max_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is greater than '%s' maximum %ld",
1710 value, errmsg, max_value);
1711 }
1712 return 0;
1713 }
1714 return 1;
1715 }
1716
1717
1718 SWIGINTERN int
1719 SWIG_AsVal_long(PyObject* obj, long* val)
1720 {
1721 if (PyNumber_Check(obj)) {
1722 if (val) *val = PyInt_AsLong(obj);
1723 return 1;
1724 }
1725 else {
1726 SWIG_type_error("number", obj);
1727 }
1728 return 0;
1729 }
1730
1731
1732 #if INT_MAX != LONG_MAX
1733 SWIGINTERN int
1734 SWIG_AsVal_int(PyObject *obj, int *val)
1735 {
1736 const char* errmsg = val ? "int" : (char*)0;
1737 long v;
1738 if (SWIG_AsVal_long(obj, &v)) {
1739 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1740 if (val) *val = (int)(v);
1741 return 1;
1742 } else {
1743 return 0;
1744 }
1745 } else {
1746 PyErr_Clear();
1747 }
1748 if (val) {
1749 SWIG_type_error(errmsg, obj);
1750 }
1751 return 0;
1752 }
1753 #else
1754 SWIGINTERNSHORT int
1755 SWIG_AsVal_int(PyObject *obj, int *val)
1756 {
1757 return SWIG_AsVal_long(obj,(long*)val);
1758 }
1759 #endif
1760
1761
1762 SWIGINTERNSHORT int
1763 SWIG_As_int(PyObject* obj)
1764 {
1765 int v;
1766 if (!SWIG_AsVal_int(obj, &v)) {
1767 /*
1768 this is needed to make valgrind/purify happier.
1769 */
1770 memset((void*)&v, 0, sizeof(int));
1771 }
1772 return v;
1773 }
1774
1775
1776 SWIGINTERNSHORT int
1777 SWIG_Check_int(PyObject* obj)
1778 {
1779 return SWIG_AsVal_int(obj, (int*)0);
1780 }
1781
1782 static PyObject *wxSize_Get(wxSize *self){
1783 bool blocked = wxPyBeginBlockThreads();
1784 PyObject* tup = PyTuple_New(2);
1785 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1786 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1787 wxPyEndBlockThreads(blocked);
1788 return tup;
1789 }
1790
1791 SWIGINTERN int
1792 SWIG_AsVal_double(PyObject *obj, double* val)
1793 {
1794 if (PyNumber_Check(obj)) {
1795 if (val) *val = PyFloat_AsDouble(obj);
1796 return 1;
1797 }
1798 else {
1799 SWIG_type_error("number", obj);
1800 }
1801 return 0;
1802 }
1803
1804
1805 SWIGINTERNSHORT double
1806 SWIG_As_double(PyObject* obj)
1807 {
1808 double v;
1809 if (!SWIG_AsVal_double(obj, &v)) {
1810 /*
1811 this is needed to make valgrind/purify happier.
1812 */
1813 memset((void*)&v, 0, sizeof(double));
1814 }
1815 return v;
1816 }
1817
1818
1819 SWIGINTERNSHORT int
1820 SWIG_Check_double(PyObject* obj)
1821 {
1822 return SWIG_AsVal_double(obj, (double*)0);
1823 }
1824
1825
1826 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1827 #define SWIG_From_double PyFloat_FromDouble
1828 /*@@*/
1829
1830 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1831 self->x = x;
1832 self->y = y;
1833 }
1834 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1835 bool blocked = wxPyBeginBlockThreads();
1836 PyObject* tup = PyTuple_New(2);
1837 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1838 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1839 wxPyEndBlockThreads(blocked);
1840 return tup;
1841 }
1842
1843 SWIGINTERNSHORT long
1844 SWIG_As_long(PyObject* obj)
1845 {
1846 long v;
1847 if (!SWIG_AsVal_long(obj, &v)) {
1848 /*
1849 this is needed to make valgrind/purify happier.
1850 */
1851 memset((void*)&v, 0, sizeof(long));
1852 }
1853 return v;
1854 }
1855
1856
1857 SWIGINTERNSHORT int
1858 SWIG_Check_long(PyObject* obj)
1859 {
1860 return SWIG_AsVal_long(obj, (long*)0);
1861 }
1862
1863 static void wxPoint_Set(wxPoint *self,long x,long y){
1864 self->x = x;
1865 self->y = y;
1866 }
1867 static PyObject *wxPoint_Get(wxPoint *self){
1868 bool blocked = wxPyBeginBlockThreads();
1869 PyObject* tup = PyTuple_New(2);
1870 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1871 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1872 wxPyEndBlockThreads(blocked);
1873 return tup;
1874 }
1875 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1876 self->x = x;
1877 self->y = y;
1878 self->width = width;
1879 self->height = height;
1880 }
1881 static PyObject *wxRect_Get(wxRect *self){
1882 bool blocked = wxPyBeginBlockThreads();
1883 PyObject* tup = PyTuple_New(4);
1884 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1885 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1886 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1887 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1888 wxPyEndBlockThreads(blocked);
1889 return tup;
1890 }
1891
1892 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1893 wxRegion reg1(*r1);
1894 wxRegion reg2(*r2);
1895 wxRect dest(0,0,0,0);
1896 PyObject* obj;
1897
1898 reg1.Intersect(reg2);
1899 dest = reg1.GetBox();
1900
1901 if (dest != wxRect(0,0,0,0)) {
1902 bool blocked = wxPyBeginBlockThreads();
1903 wxRect* newRect = new wxRect(dest);
1904 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1905 wxPyEndBlockThreads(blocked);
1906 return obj;
1907 }
1908 Py_INCREF(Py_None);
1909 return Py_None;
1910 }
1911
1912
1913 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1914 PyObject* o2;
1915 PyObject* o3;
1916
1917 if (!target) {
1918 target = o;
1919 } else if (target == Py_None) {
1920 Py_DECREF(Py_None);
1921 target = o;
1922 } else {
1923 if (!PyTuple_Check(target)) {
1924 o2 = target;
1925 target = PyTuple_New(1);
1926 PyTuple_SetItem(target, 0, o2);
1927 }
1928 o3 = PyTuple_New(1);
1929 PyTuple_SetItem(o3, 0, o);
1930
1931 o2 = target;
1932 target = PySequence_Concat(o2, o3);
1933 Py_DECREF(o2);
1934 Py_DECREF(o3);
1935 }
1936 return target;
1937 }
1938
1939
1940 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1941 self->m_x = x;
1942 self->m_y = y;
1943 }
1944 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1945 bool blocked = wxPyBeginBlockThreads();
1946 PyObject* tup = PyTuple_New(2);
1947 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1948 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1949 wxPyEndBlockThreads(blocked);
1950 return tup;
1951 }
1952
1953 #include "wx/wxPython/pyistream.h"
1954
1955 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1956 wxInputStream* wxis = wxPyCBInputStream::create(p);
1957 if (wxis)
1958 return new wxPyInputStream(wxis);
1959 else
1960 return NULL;
1961 }
1962
1963 SWIGINTERNSHORT PyObject*
1964 SWIG_From_char(char c)
1965 {
1966 return PyString_FromStringAndSize(&c,1);
1967 }
1968
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_unsigned_SS_long(unsigned long value)
1972 {
1973 return (value > LONG_MAX) ?
1974 PyLong_FromUnsignedLong(value)
1975 : PyInt_FromLong((long)(value));
1976 }
1977
1978
1979 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1980 SWIGINTERN int
1981 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1982 {
1983 static swig_type_info* pchar_info = 0;
1984 char* vptr = 0;
1985 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1986 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1987 if (cptr) *cptr = vptr;
1988 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1989 return SWIG_OLDOBJ;
1990 } else {
1991 PyErr_Clear();
1992 if (PyString_Check(obj)) {
1993 if (cptr) {
1994 *cptr = PyString_AS_STRING(obj);
1995 if (psize) {
1996 *psize = PyString_GET_SIZE(obj) + 1;
1997 }
1998 }
1999 return SWIG_PYSTR;
2000 }
2001 }
2002 if (cptr) {
2003 SWIG_type_error("char *", obj);
2004 }
2005 return 0;
2006 }
2007
2008
2009 SWIGINTERN int
2010 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2011 {
2012 char* cptr; size_t csize;
2013 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2014 /* in C you can do:
2015
2016 char x[5] = "hello";
2017
2018 ie, assing the array using an extra '0' char.
2019 */
2020 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2021 if (csize <= size) {
2022 if (val) {
2023 if (csize) memcpy(val, cptr, csize);
2024 if (csize < size) memset(val + csize, 0, size - csize);
2025 }
2026 return 1;
2027 }
2028 }
2029 if (val) {
2030 PyErr_Format(PyExc_TypeError,
2031 "a char array of maximum size %lu is expected",
2032 (unsigned long) size);
2033 }
2034 return 0;
2035 }
2036
2037
2038 SWIGINTERN int
2039 SWIG_AsVal_char(PyObject *obj, char *val)
2040 {
2041 const char* errmsg = val ? "char" : (char*)0;
2042 long v;
2043 if (SWIG_AsVal_long(obj, &v)) {
2044 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2045 if (val) *val = (char)(v);
2046 return 1;
2047 } else {
2048 return 0;
2049 }
2050 } else {
2051 PyErr_Clear();
2052 return SWIG_AsCharArray(obj, val, 1);
2053 }
2054 }
2055
2056
2057 SWIGINTERNSHORT char
2058 SWIG_As_char(PyObject* obj)
2059 {
2060 char v;
2061 if (!SWIG_AsVal_char(obj, &v)) {
2062 /*
2063 this is needed to make valgrind/purify happier.
2064 */
2065 memset((void*)&v, 0, sizeof(char));
2066 }
2067 return v;
2068 }
2069
2070
2071 SWIGINTERNSHORT int
2072 SWIG_Check_char(PyObject* obj)
2073 {
2074 return SWIG_AsVal_char(obj, (char*)0);
2075 }
2076
2077
2078 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2079 #define SWIG_From_long PyInt_FromLong
2080 /*@@*/
2081
2082 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2083 // We use only strings for the streams, not unicode
2084 PyObject* str = PyObject_Str(obj);
2085 if (! str) {
2086 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2087 return;
2088 }
2089 self->Write(PyString_AS_STRING(str),
2090 PyString_GET_SIZE(str));
2091 Py_DECREF(str);
2092 }
2093
2094 #include "wx/wxPython/pyistream.h"
2095
2096
2097 class wxPyFileSystemHandler : public wxFileSystemHandler
2098 {
2099 public:
2100 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2101
2102 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2103 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2104 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2105 DEC_PYCALLBACK_STRING__pure(FindNext);
2106
2107 wxString GetProtocol(const wxString& location) {
2108 return wxFileSystemHandler::GetProtocol(location);
2109 }
2110
2111 wxString GetLeftLocation(const wxString& location) {
2112 return wxFileSystemHandler::GetLeftLocation(location);
2113 }
2114
2115 wxString GetAnchor(const wxString& location) {
2116 return wxFileSystemHandler::GetAnchor(location);
2117 }
2118
2119 wxString GetRightLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetRightLocation(location);
2121 }
2122
2123 wxString GetMimeTypeFromExt(const wxString& location) {
2124 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2125 }
2126
2127 PYPRIVATE;
2128 };
2129
2130
2131 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2132 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2133 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2134 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2135
2136
2137 SWIGINTERN int
2138 SWIG_AsVal_bool(PyObject *obj, bool *val)
2139 {
2140 if (obj == Py_True) {
2141 if (val) *val = true;
2142 return 1;
2143 }
2144 if (obj == Py_False) {
2145 if (val) *val = false;
2146 return 1;
2147 }
2148 int res = 0;
2149 if (SWIG_AsVal_int(obj, &res)) {
2150 if (val) *val = res ? true : false;
2151 return 1;
2152 } else {
2153 PyErr_Clear();
2154 }
2155 if (val) {
2156 SWIG_type_error("bool", obj);
2157 }
2158 return 0;
2159 }
2160
2161
2162 SWIGINTERNSHORT bool
2163 SWIG_As_bool(PyObject* obj)
2164 {
2165 bool v;
2166 if (!SWIG_AsVal_bool(obj, &v)) {
2167 /*
2168 this is needed to make valgrind/purify happier.
2169 */
2170 memset((void*)&v, 0, sizeof(bool));
2171 }
2172 return v;
2173 }
2174
2175
2176 SWIGINTERNSHORT int
2177 SWIG_Check_bool(PyObject* obj)
2178 {
2179 return SWIG_AsVal_bool(obj, (bool*)0);
2180 }
2181
2182 static wxString FileSystem_URLToFileName(wxString const &url){
2183 wxFileName fname = wxFileSystem::URLToFileName(url);
2184 return fname.GetFullPath();
2185 }
2186
2187 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2188 wxImage& image,
2189 long type) {
2190 wxMemoryFSHandler::AddFile(filename, image, type);
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2194 const wxBitmap& bitmap,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2200 PyObject* data) {
2201 if (! PyString_Check(data)) {
2202 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2203 "Expected string object"));
2204 return;
2205 }
2206
2207 bool blocked = wxPyBeginBlockThreads();
2208 void* ptr = (void*)PyString_AsString(data);
2209 size_t size = PyString_Size(data);
2210 wxPyEndBlockThreads(blocked);
2211
2212 wxMemoryFSHandler::AddFile(filename, ptr, size);
2213 }
2214
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 SWIGINTERN int
2220 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2221 {
2222 long v = 0;
2223 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2224 SWIG_type_error("unsigned number", obj);
2225 }
2226 else if (val)
2227 *val = (unsigned long)v;
2228 return 1;
2229 }
2230
2231
2232 SWIGINTERNSHORT int
2233 SWIG_CheckUnsignedLongInRange(unsigned long value,
2234 unsigned long max_value,
2235 const char *errmsg)
2236 {
2237 if (value > max_value) {
2238 if (errmsg) {
2239 PyErr_Format(PyExc_OverflowError,
2240 "value %lu is greater than '%s' minimum %lu",
2241 value, errmsg, max_value);
2242 }
2243 return 0;
2244 }
2245 return 1;
2246 }
2247
2248
2249 SWIGINTERN int
2250 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2251 {
2252 const char* errmsg = val ? "unsigned char" : (char*)0;
2253 unsigned long v;
2254 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2255 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2256 if (val) *val = (unsigned char)(v);
2257 return 1;
2258 } else {
2259 return 0;
2260 }
2261 } else {
2262 PyErr_Clear();
2263 }
2264 if (val) {
2265 SWIG_type_error(errmsg, obj);
2266 }
2267 return 0;
2268 }
2269
2270
2271 SWIGINTERNSHORT unsigned char
2272 SWIG_As_unsigned_SS_char(PyObject* obj)
2273 {
2274 unsigned char v;
2275 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2276 /*
2277 this is needed to make valgrind/purify happier.
2278 */
2279 memset((void*)&v, 0, sizeof(unsigned char));
2280 }
2281 return v;
2282 }
2283
2284
2285 SWIGINTERNSHORT int
2286 SWIG_Check_unsigned_SS_char(PyObject* obj)
2287 {
2288 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2289 }
2290
2291
2292 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2293 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2294 /*@@*/
2295
2296
2297 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2298 if (width > 0 && height > 0)
2299 return new wxImage(width, height, clear);
2300 else
2301 return new wxImage;
2302 }
2303 static wxImage *new_wxImage(wxBitmap const &bitmap){
2304 return new wxImage(bitmap.ConvertToImage());
2305 }
2306 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2307 // Copy the source data so the wxImage can clean it up later
2308 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2309 if (copy == NULL) {
2310 PyErr_NoMemory();
2311 return NULL;
2312 }
2313 memcpy(copy, data, width*height*3);
2314 return new wxImage(width, height, copy, false);
2315 }
2316 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2317 // Copy the source data so the wxImage can clean it up later
2318 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2319 if (dcopy == NULL) {
2320 PyErr_NoMemory();
2321 return NULL;
2322 }
2323 memcpy(dcopy, data, width*height*3);
2324 unsigned char* acopy = (unsigned char*)malloc(width*height);
2325 if (acopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(acopy, alpha, width*height);
2330
2331 return new wxImage(width, height, dcopy, acopy, false);
2332 }
2333 static wxSize wxImage_GetSize(wxImage *self){
2334 wxSize size(self->GetWidth(), self->GetHeight());
2335 return size;
2336 }
2337 static PyObject *wxImage_GetData(wxImage *self){
2338 unsigned char* data = self->GetData();
2339 int len = self->GetWidth() * self->GetHeight() * 3;
2340 PyObject* rv;
2341 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2342 return rv;
2343 }
2344 static void wxImage_SetData(wxImage *self,PyObject *data){
2345 unsigned char* dataPtr;
2346
2347 if (! PyString_Check(data)) {
2348 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2349 "Expected string object"));
2350 return /* NULL */ ;
2351 }
2352
2353 size_t len = self->GetWidth() * self->GetHeight() * 3;
2354 dataPtr = (unsigned char*) malloc(len);
2355 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2356 self->SetData(dataPtr);
2357 // wxImage takes ownership of dataPtr...
2358 }
2359 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2360 unsigned char* data = self->GetData();
2361 int len = self->GetWidth() * self->GetHeight() * 3;
2362 PyObject* rv;
2363 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2364 return rv;
2365 }
2366 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2367 unsigned char* buffer;
2368 int size;
2369
2370 bool blocked = wxPyBeginBlockThreads();
2371 if (!PyArg_Parse(data, "t#", &buffer, &size))
2372 goto done;
2373
2374 if (size != self->GetWidth() * self->GetHeight() * 3) {
2375 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2376 goto done;
2377 }
2378 self->SetData(buffer);
2379 done:
2380 wxPyEndBlockThreads(blocked);
2381 }
2382 static PyObject *wxImage_GetAlphaData(wxImage *self){
2383 unsigned char* data = self->GetAlpha();
2384 if (! data) {
2385 RETURN_NONE();
2386 } else {
2387 int len = self->GetWidth() * self->GetHeight();
2388 PyObject* rv;
2389 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2390 return rv;
2391 }
2392 }
2393 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2394 unsigned char* dataPtr;
2395
2396 if (! PyString_Check(data)) {
2397 PyErr_SetString(PyExc_TypeError, "Expected string object");
2398 return /* NULL */ ;
2399 }
2400
2401 size_t len = self->GetWidth() * self->GetHeight();
2402 dataPtr = (unsigned char*) malloc(len);
2403 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2404 self->SetAlpha(dataPtr);
2405 // wxImage takes ownership of dataPtr...
2406 }
2407 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2408 unsigned char* data = self->GetAlpha();
2409 int len = self->GetWidth() * self->GetHeight();
2410 PyObject* rv;
2411 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2412 return rv;
2413 }
2414 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2415 unsigned char* buffer;
2416 int size;
2417
2418 bool blocked = wxPyBeginBlockThreads();
2419 if (!PyArg_Parse(data, "t#", &buffer, &size))
2420 goto done;
2421
2422 if (size != self->GetWidth() * self->GetHeight()) {
2423 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2424 goto done;
2425 }
2426 self->SetAlpha(buffer);
2427 done:
2428 wxPyEndBlockThreads(blocked);
2429 }
2430
2431 SWIGINTERNSHORT unsigned long
2432 SWIG_As_unsigned_SS_long(PyObject* obj)
2433 {
2434 unsigned long v;
2435 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2436 /*
2437 this is needed to make valgrind/purify happier.
2438 */
2439 memset((void*)&v, 0, sizeof(unsigned long));
2440 }
2441 return v;
2442 }
2443
2444
2445 SWIGINTERNSHORT int
2446 SWIG_Check_unsigned_SS_long(PyObject* obj)
2447 {
2448 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2449 }
2450
2451 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2452 wxBitmap bitmap(*self, depth);
2453 return bitmap;
2454 }
2455 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2456 wxImage mono = self->ConvertToMono( red, green, blue );
2457 wxBitmap bitmap( mono, 1 );
2458 return bitmap;
2459 }
2460 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2461 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2462 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2463 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2464 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2465
2466 #include <wx/quantize.h>
2467
2468 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2469 return wxQuantize::Quantize(src, dest,
2470 //NULL, // palette
2471 desiredNoColours,
2472 NULL, // eightBitData
2473 flags);
2474 }
2475 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2476 if (PyCallable_Check(func)) {
2477 self->Connect(id, lastId, eventType,
2478 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2479 new wxPyCallback(func));
2480 }
2481 else if (func == Py_None) {
2482 self->Disconnect(id, lastId, eventType,
2483 (wxObjectEventFunction)
2484 &wxPyCallback::EventThunker);
2485 }
2486 else {
2487 wxPyBLOCK_THREADS(
2488 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2489 }
2490 }
2491 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2492 return self->Disconnect(id, lastId, eventType,
2493 (wxObjectEventFunction)
2494 &wxPyCallback::EventThunker);
2495 }
2496 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2497 if (_self && _self != Py_None) {
2498 self->SetClientObject(new wxPyOORClientData(_self, incref));
2499 }
2500 else {
2501 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2502 if (data) {
2503 self->SetClientObject(NULL); // This will delete it too
2504 }
2505 }
2506 }
2507
2508 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2509 #if wxUSE_UNICODE
2510 return self->GetUnicodeKey();
2511 #else
2512 return 0;
2513 #endif
2514 }
2515
2516 #if UINT_MAX < LONG_MAX
2517 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2518 #define SWIG_From_unsigned_SS_int SWIG_From_long
2519 /*@@*/
2520 #else
2521 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2522 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2523 /*@@*/
2524 #endif
2525
2526
2527 #if UINT_MAX != ULONG_MAX
2528 SWIGINTERN int
2529 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2530 {
2531 const char* errmsg = val ? "unsigned int" : (char*)0;
2532 unsigned long v;
2533 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2534 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2535 if (val) *val = (unsigned int)(v);
2536 return 1;
2537 }
2538 } else {
2539 PyErr_Clear();
2540 }
2541 if (val) {
2542 SWIG_type_error(errmsg, obj);
2543 }
2544 return 0;
2545 }
2546 #else
2547 SWIGINTERNSHORT unsigned int
2548 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2549 {
2550 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2551 }
2552 #endif
2553
2554
2555 SWIGINTERNSHORT unsigned int
2556 SWIG_As_unsigned_SS_int(PyObject* obj)
2557 {
2558 unsigned int v;
2559 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2560 /*
2561 this is needed to make valgrind/purify happier.
2562 */
2563 memset((void*)&v, 0, sizeof(unsigned int));
2564 }
2565 return v;
2566 }
2567
2568
2569 SWIGINTERNSHORT int
2570 SWIG_Check_unsigned_SS_int(PyObject* obj)
2571 {
2572 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2573 }
2574
2575 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2576 self->m_size = size;
2577 }
2578 static void wxMoveEvent_SetPosition(wxMoveEvent *self,wxPoint pos){
2579 self->m_pos = pos;
2580 }
2581 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2582 int count = self->GetNumberOfFiles();
2583 wxString* files = self->GetFiles();
2584 PyObject* list = PyList_New(count);
2585
2586 if (!list) {
2587 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2588 return NULL;
2589 }
2590
2591 for (int i=0; i<count; i++) {
2592 PyList_SetItem(list, i, wx2PyString(files[i]));
2593 }
2594 return list;
2595 }
2596
2597
2598 static wxPyApp *new_wxPyApp(){
2599 wxPythonApp = new wxPyApp();
2600 return wxPythonApp;
2601 }
2602
2603 void wxApp_CleanUp() {
2604 __wxPyCleanup();
2605 }
2606
2607
2608 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2609
2610
2611 SWIGINTERNSHORT int
2612 SWIG_AsCharPtr(PyObject *obj, char **val)
2613 {
2614 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2615 return 1;
2616 }
2617 if (val) {
2618 PyErr_Clear();
2619 SWIG_type_error("char *", obj);
2620 }
2621 return 0;
2622 }
2623
2624
2625 SWIGINTERN PyObject *
2626 SWIG_FromCharPtr(const char* cptr)
2627 {
2628 if (cptr) {
2629 size_t size = strlen(cptr);
2630 if (size > INT_MAX) {
2631 return SWIG_NewPointerObj((char*)(cptr),
2632 SWIG_TypeQuery("char *"), 0);
2633 } else {
2634 if (size != 0) {
2635 return PyString_FromStringAndSize(cptr, size);
2636 } else {
2637 return PyString_FromString(cptr);
2638 }
2639 }
2640 }
2641 Py_INCREF(Py_None);
2642 return Py_None;
2643 }
2644
2645
2646 #ifdef __WXMAC__
2647
2648 // A dummy class that raises an exception if used...
2649 class wxEventLoop
2650 {
2651 public:
2652 wxEventLoop() { wxPyRaiseNotImplemented(); }
2653 int Run() { return 0; }
2654 void Exit(int rc = 0) {}
2655 bool Pending() const { return false; }
2656 bool Dispatch() { return false; }
2657 bool IsRunning() const { return false; }
2658 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2659 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2660 };
2661
2662 #else
2663
2664 #include <wx/evtloop.h>
2665
2666 #endif
2667
2668
2669
2670 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2671 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2672 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2673 static PyObject *wxWindow_GetChildren(wxWindow *self){
2674 wxWindowList& list = self->GetChildren();
2675 return wxPy_ConvertList(&list);
2676 }
2677 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2678 #if wxUSE_HOTKEY
2679 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2680 #else
2681 return false;
2682 #endif
2683 }
2684 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2685
2686
2687
2688 return false;
2689
2690 }
2691 static long wxWindow_GetHandle(wxWindow *self){
2692 return wxPyGetWinHandle(self);
2693 }
2694 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2695 self->AssociateHandle((WXWidget)handle);
2696 }
2697
2698 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2699 return wxWindow::FindWindowById(id, parent);
2700 }
2701
2702 wxWindow* wxFindWindowByName( const wxString& name,
2703 const wxWindow *parent = NULL ) {
2704 return wxWindow::FindWindowByName(name, parent);
2705 }
2706
2707 wxWindow* wxFindWindowByLabel( const wxString& label,
2708 const wxWindow *parent = NULL ) {
2709 return wxWindow::FindWindowByLabel(label, parent);
2710 }
2711
2712
2713 #ifdef __WXMSW__
2714 #include <wx/msw/private.h> // to get wxGetWindowId
2715 #endif
2716
2717
2718 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2719 #ifdef __WXMSW__
2720 WXHWND hWnd = (WXHWND)_hWnd;
2721 long id = wxGetWindowId(hWnd);
2722 wxWindow* win = new wxWindow;
2723 parent->AddChild(win);
2724 win->SetEventHandler(win);
2725 win->SetHWND(hWnd);
2726 win->SetId(id);
2727 win->SubclassWin(hWnd);
2728 win->AdoptAttributesFromHWND();
2729 win->SetupColours();
2730 return win;
2731 #else
2732 wxPyRaiseNotImplemented();
2733 return NULL;
2734 #endif
2735 }
2736
2737
2738 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2739 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2740 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2741
2742 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2743
2744 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2745 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2746 wxMenuItemList& list = self->GetMenuItems();
2747 return wxPy_ConvertList(&list);
2748 }
2749 static const wxString wxPyControlNameStr(wxControlNameStr);
2750 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2751 if (clientData) {
2752 wxPyClientData* data = new wxPyClientData(clientData);
2753 return self->Append(item, data);
2754 } else
2755 return self->Append(item);
2756 }
2757 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2758 if (clientData) {
2759 wxPyClientData* data = new wxPyClientData(clientData);
2760 return self->Insert(item, pos, data);
2761 } else
2762 return self->Insert(item, pos);
2763 }
2764 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2765 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2766 if (data) {
2767 Py_INCREF(data->m_obj);
2768 return data->m_obj;
2769 } else {
2770 Py_INCREF(Py_None);
2771 return Py_None;
2772 }
2773 }
2774 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2775 wxPyClientData* data = new wxPyClientData(clientData);
2776 self->SetClientObject(n, data);
2777 }
2778
2779
2780 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2781 wxPyUserData* data = NULL;
2782 if ( userData ) {
2783 bool blocked = wxPyBeginBlockThreads();
2784 data = new wxPyUserData(userData);
2785 wxPyEndBlockThreads(blocked);
2786 }
2787 return new wxSizerItem(window, proportion, flag, border, data);
2788 }
2789 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2790 wxPyUserData* data = NULL;
2791 if ( userData ) {
2792 bool blocked = wxPyBeginBlockThreads();
2793 data = new wxPyUserData(userData);
2794 wxPyEndBlockThreads(blocked);
2795 }
2796 return new wxSizerItem(width, height, proportion, flag, border, data);
2797 }
2798 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2799 wxPyUserData* data = NULL;
2800 if ( userData ) {
2801 bool blocked = wxPyBeginBlockThreads();
2802 data = new wxPyUserData(userData);
2803 wxPyEndBlockThreads(blocked);
2804 }
2805 return new wxSizerItem(sizer, proportion, flag, border, data);
2806 }
2807
2808 #include <float.h>
2809 SWIGINTERN int
2810 SWIG_CheckDoubleInRange(double value, double min_value,
2811 double max_value, const char* errmsg)
2812 {
2813 if (value < min_value) {
2814 if (errmsg) {
2815 PyErr_Format(PyExc_OverflowError,
2816 "value %g is less than %s minimum %g",
2817 value, errmsg, min_value);
2818 }
2819 return 0;
2820 } else if (value > max_value) {
2821 if (errmsg) {
2822 PyErr_Format(PyExc_OverflowError,
2823 "value %g is greater than %s maximum %g",
2824 value, errmsg, max_value);
2825 }
2826 return 0;
2827 }
2828 return 1;
2829 }
2830
2831
2832 SWIGINTERN int
2833 SWIG_AsVal_float(PyObject *obj, float *val)
2834 {
2835 const char* errmsg = val ? "float" : (char*)0;
2836 double v;
2837 if (SWIG_AsVal_double(obj, &v)) {
2838 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2839 if (val) *val = (float)(v);
2840 return 1;
2841 } else {
2842 return 0;
2843 }
2844 } else {
2845 PyErr_Clear();
2846 }
2847 if (val) {
2848 SWIG_type_error(errmsg, obj);
2849 }
2850 return 0;
2851 }
2852
2853
2854 SWIGINTERNSHORT float
2855 SWIG_As_float(PyObject* obj)
2856 {
2857 float v;
2858 if (!SWIG_AsVal_float(obj, &v)) {
2859 /*
2860 this is needed to make valgrind/purify happier.
2861 */
2862 memset((void*)&v, 0, sizeof(float));
2863 }
2864 return v;
2865 }
2866
2867
2868 SWIGINTERNSHORT int
2869 SWIG_Check_float(PyObject* obj)
2870 {
2871 return SWIG_AsVal_float(obj, (float*)0);
2872 }
2873
2874
2875 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2876 #define SWIG_From_float PyFloat_FromDouble
2877 /*@@*/
2878
2879 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2880 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2881 if (data) {
2882 Py_INCREF(data->m_obj);
2883 return data->m_obj;
2884 } else {
2885 Py_INCREF(Py_None);
2886 return Py_None;
2887 }
2888 }
2889
2890 // Figure out the type of the sizer item
2891
2892 struct wxPySizerItemInfo {
2893 wxPySizerItemInfo()
2894 : window(NULL), sizer(NULL), gotSize(false),
2895 size(wxDefaultSize), gotPos(false), pos(-1)
2896 {}
2897
2898 wxWindow* window;
2899 wxSizer* sizer;
2900 bool gotSize;
2901 wxSize size;
2902 bool gotPos;
2903 int pos;
2904 };
2905
2906 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2907
2908 wxPySizerItemInfo info;
2909 wxSize size;
2910 wxSize* sizePtr = &size;
2911
2912 // Find out what the type of the item is
2913 // try wxWindow
2914 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2915 PyErr_Clear();
2916 info.window = NULL;
2917
2918 // try wxSizer
2919 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2920 PyErr_Clear();
2921 info.sizer = NULL;
2922
2923 // try wxSize or (w,h)
2924 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2925 info.size = *sizePtr;
2926 info.gotSize = true;
2927 }
2928
2929 // or a single int
2930 if (checkIdx && PyInt_Check(item)) {
2931 info.pos = PyInt_AsLong(item);
2932 info.gotPos = true;
2933 }
2934 }
2935 }
2936
2937 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2938 // no expected type, figure out what kind of error message to generate
2939 if ( !checkSize && !checkIdx )
2940 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2941 else if ( checkSize && !checkIdx )
2942 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2943 else if ( !checkSize && checkIdx)
2944 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2945 else
2946 // can this one happen?
2947 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2948 }
2949
2950 return info;
2951 }
2952
2953 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2954 if (!self->GetClientObject())
2955 self->SetClientObject(new wxPyOORClientData(_self));
2956 }
2957 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2958
2959 wxPyUserData* data = NULL;
2960 bool blocked = wxPyBeginBlockThreads();
2961 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2962 if ( userData && (info.window || info.sizer || info.gotSize) )
2963 data = new wxPyUserData(userData);
2964 wxPyEndBlockThreads(blocked);
2965
2966 // Now call the real Add method if a valid item type was found
2967 if ( info.window )
2968 return self->Add(info.window, proportion, flag, border, data);
2969 else if ( info.sizer )
2970 return self->Add(info.sizer, proportion, flag, border, data);
2971 else if (info.gotSize)
2972 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2973 proportion, flag, border, data);
2974 else
2975 return NULL;
2976 }
2977 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2978
2979 wxPyUserData* data = NULL;
2980 bool blocked = wxPyBeginBlockThreads();
2981 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2982 if ( userData && (info.window || info.sizer || info.gotSize) )
2983 data = new wxPyUserData(userData);
2984 wxPyEndBlockThreads(blocked);
2985
2986 // Now call the real Insert method if a valid item type was found
2987 if ( info.window )
2988 return self->Insert(before, info.window, proportion, flag, border, data);
2989 else if ( info.sizer )
2990 return self->Insert(before, info.sizer, proportion, flag, border, data);
2991 else if (info.gotSize)
2992 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2993 proportion, flag, border, data);
2994 else
2995 return NULL;
2996 }
2997 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2998
2999 wxPyUserData* data = NULL;
3000 bool blocked = wxPyBeginBlockThreads();
3001 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3002 if ( userData && (info.window || info.sizer || info.gotSize) )
3003 data = new wxPyUserData(userData);
3004 wxPyEndBlockThreads(blocked);
3005
3006 // Now call the real Prepend method if a valid item type was found
3007 if ( info.window )
3008 return self->Prepend(info.window, proportion, flag, border, data);
3009 else if ( info.sizer )
3010 return self->Prepend(info.sizer, proportion, flag, border, data);
3011 else if (info.gotSize)
3012 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3013 proportion, flag, border, data);
3014 else
3015 return NULL;
3016 }
3017 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3018 bool blocked = wxPyBeginBlockThreads();
3019 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3020 wxPyEndBlockThreads(blocked);
3021 if ( info.window )
3022 return self->Remove(info.window);
3023 else if ( info.sizer )
3024 return self->Remove(info.sizer);
3025 else if ( info.gotPos )
3026 return self->Remove(info.pos);
3027 else
3028 return false;
3029 }
3030 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3031 bool blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3033 wxPyEndBlockThreads(blocked);
3034 if ( info.window )
3035 return self->Detach(info.window);
3036 else if ( info.sizer )
3037 return self->Detach(info.sizer);
3038 else if ( info.gotPos )
3039 return self->Detach(info.pos);
3040 else
3041 return false;
3042 }
3043 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3044 bool blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3046 wxPyEndBlockThreads(blocked);
3047 if ( info.window )
3048 return self->GetItem(info.window);
3049 else if ( info.sizer )
3050 return self->GetItem(info.sizer);
3051 else if ( info.gotPos )
3052 return self->GetItem(info.pos);
3053 else
3054 return NULL;
3055 }
3056 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3057 bool blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 self->SetItemMinSize(info.window, size);
3062 else if ( info.sizer )
3063 self->SetItemMinSize(info.sizer, size);
3064 else if ( info.gotPos )
3065 self->SetItemMinSize(info.pos, size);
3066 }
3067 static PyObject *wxSizer_GetChildren(wxSizer *self){
3068 wxSizerItemList& list = self->GetChildren();
3069 return wxPy_ConvertList(&list);
3070 }
3071 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3072 bool blocked = wxPyBeginBlockThreads();
3073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3074 wxPyEndBlockThreads(blocked);
3075 if ( info.window )
3076 return self->Show(info.window, show, recursive);
3077 else if ( info.sizer )
3078 return self->Show(info.sizer, show, recursive);
3079 else if ( info.gotPos )
3080 return self->Show(info.pos, show);
3081 else
3082 return false;
3083 }
3084 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3085 bool blocked = wxPyBeginBlockThreads();
3086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3087 wxPyEndBlockThreads(blocked);
3088 if ( info.window )
3089 return self->IsShown(info.window);
3090 else if ( info.sizer )
3091 return self->IsShown(info.sizer);
3092 else if ( info.gotPos )
3093 return self->IsShown(info.pos);
3094 else
3095 return false;
3096 }
3097
3098 // See pyclasses.h
3099 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3100 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3101 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3102
3103
3104
3105
3106 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3107 {
3108 if (source == Py_None) {
3109 **obj = wxGBPosition(-1,-1);
3110 return true;
3111 }
3112 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3113 }
3114
3115 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3116 {
3117 if (source == Py_None) {
3118 **obj = wxGBSpan(-1,-1);
3119 return true;
3120 }
3121 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3122 }
3123
3124
3125 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3126 self->SetRow(row);
3127 self->SetCol(col);
3128 }
3129 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3130 bool blocked = wxPyBeginBlockThreads();
3131 PyObject* tup = PyTuple_New(2);
3132 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3133 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3134 wxPyEndBlockThreads(blocked);
3135 return tup;
3136 }
3137 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3138 self->SetRowspan(rowspan);
3139 self->SetColspan(colspan);
3140 }
3141 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3142 bool blocked = wxPyBeginBlockThreads();
3143 PyObject* tup = PyTuple_New(2);
3144 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3145 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3146 wxPyEndBlockThreads(blocked);
3147 return tup;
3148 }
3149 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3150 wxPyUserData* data = NULL;
3151 if ( userData ) {
3152 bool blocked = wxPyBeginBlockThreads();
3153 data = new wxPyUserData(userData);
3154 wxPyEndBlockThreads(blocked);
3155 }
3156 return new wxGBSizerItem(window, pos, span, flag, border, data);
3157 }
3158 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3159 wxPyUserData* data = NULL;
3160 if ( userData ) {
3161 bool blocked = wxPyBeginBlockThreads();
3162 data = new wxPyUserData(userData);
3163 wxPyEndBlockThreads(blocked);
3164 }
3165 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3166 }
3167 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3168 wxPyUserData* data = NULL;
3169 if ( userData ) {
3170 bool blocked = wxPyBeginBlockThreads();
3171 data = new wxPyUserData(userData);
3172 wxPyEndBlockThreads(blocked);
3173 }
3174 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3175 }
3176 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3177 int row, col;
3178 self->GetEndPos(row, col);
3179 return wxGBPosition(row, col);
3180 }
3181 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3182
3183 wxPyUserData* data = NULL;
3184 bool blocked = wxPyBeginBlockThreads();
3185 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3186 if ( userData && (info.window || info.sizer || info.gotSize) )
3187 data = new wxPyUserData(userData);
3188 wxPyEndBlockThreads(blocked);
3189
3190 // Now call the real Add method if a valid item type was found
3191 if ( info.window )
3192 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3193 else if ( info.sizer )
3194 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3195 else if (info.gotSize)
3196 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3197 pos, span, flag, border, data);
3198 return NULL;
3199 }
3200
3201
3202 #ifdef __cplusplus
3203 extern "C" {
3204 #endif
3205 static int _wrap_EmptyString_set(PyObject *) {
3206 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3207 return 1;
3208 }
3209
3210
3211 static PyObject *_wrap_EmptyString_get(void) {
3212 PyObject *pyobj;
3213
3214 {
3215 #if wxUSE_UNICODE
3216 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3217 #else
3218 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3219 #endif
3220 }
3221 return pyobj;
3222 }
3223
3224
3225 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3226 PyObject *resultobj;
3227 wxObject *arg1 = (wxObject *) 0 ;
3228 wxString result;
3229 PyObject * obj0 = 0 ;
3230 char *kwnames[] = {
3231 (char *) "self", NULL
3232 };
3233
3234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3236 if (SWIG_arg_fail(1)) SWIG_fail;
3237 {
3238 PyThreadState* __tstate = wxPyBeginAllowThreads();
3239 result = wxObject_GetClassName(arg1);
3240
3241 wxPyEndAllowThreads(__tstate);
3242 if (PyErr_Occurred()) SWIG_fail;
3243 }
3244 {
3245 #if wxUSE_UNICODE
3246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3247 #else
3248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3249 #endif
3250 }
3251 return resultobj;
3252 fail:
3253 return NULL;
3254 }
3255
3256
3257 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3258 PyObject *resultobj;
3259 wxObject *arg1 = (wxObject *) 0 ;
3260 PyObject * obj0 = 0 ;
3261 char *kwnames[] = {
3262 (char *) "self", NULL
3263 };
3264
3265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3267 if (SWIG_arg_fail(1)) SWIG_fail;
3268 {
3269 PyThreadState* __tstate = wxPyBeginAllowThreads();
3270 wxObject_Destroy(arg1);
3271
3272 wxPyEndAllowThreads(__tstate);
3273 if (PyErr_Occurred()) SWIG_fail;
3274 }
3275 Py_INCREF(Py_None); resultobj = Py_None;
3276 return resultobj;
3277 fail:
3278 return NULL;
3279 }
3280
3281
3282 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3283 PyObject *obj;
3284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3285 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3286 Py_INCREF(obj);
3287 return Py_BuildValue((char *)"");
3288 }
3289 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3290 PyObject *resultobj;
3291 wxSize *arg1 = (wxSize *) 0 ;
3292 int arg2 ;
3293 PyObject * obj0 = 0 ;
3294 PyObject * obj1 = 0 ;
3295 char *kwnames[] = {
3296 (char *) "self",(char *) "x", NULL
3297 };
3298
3299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3301 if (SWIG_arg_fail(1)) SWIG_fail;
3302 {
3303 arg2 = (int)(SWIG_As_int(obj1));
3304 if (SWIG_arg_fail(2)) SWIG_fail;
3305 }
3306 if (arg1) (arg1)->x = arg2;
3307
3308 Py_INCREF(Py_None); resultobj = Py_None;
3309 return resultobj;
3310 fail:
3311 return NULL;
3312 }
3313
3314
3315 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxSize *arg1 = (wxSize *) 0 ;
3318 int result;
3319 PyObject * obj0 = 0 ;
3320 char *kwnames[] = {
3321 (char *) "self", NULL
3322 };
3323
3324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3326 if (SWIG_arg_fail(1)) SWIG_fail;
3327 result = (int) ((arg1)->x);
3328
3329 {
3330 resultobj = SWIG_From_int((int)(result));
3331 }
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3339 PyObject *resultobj;
3340 wxSize *arg1 = (wxSize *) 0 ;
3341 int arg2 ;
3342 PyObject * obj0 = 0 ;
3343 PyObject * obj1 = 0 ;
3344 char *kwnames[] = {
3345 (char *) "self",(char *) "y", NULL
3346 };
3347
3348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3350 if (SWIG_arg_fail(1)) SWIG_fail;
3351 {
3352 arg2 = (int)(SWIG_As_int(obj1));
3353 if (SWIG_arg_fail(2)) SWIG_fail;
3354 }
3355 if (arg1) (arg1)->y = arg2;
3356
3357 Py_INCREF(Py_None); resultobj = Py_None;
3358 return resultobj;
3359 fail:
3360 return NULL;
3361 }
3362
3363
3364 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3365 PyObject *resultobj;
3366 wxSize *arg1 = (wxSize *) 0 ;
3367 int result;
3368 PyObject * obj0 = 0 ;
3369 char *kwnames[] = {
3370 (char *) "self", NULL
3371 };
3372
3373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3375 if (SWIG_arg_fail(1)) SWIG_fail;
3376 result = (int) ((arg1)->y);
3377
3378 {
3379 resultobj = SWIG_From_int((int)(result));
3380 }
3381 return resultobj;
3382 fail:
3383 return NULL;
3384 }
3385
3386
3387 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3388 PyObject *resultobj;
3389 int arg1 = (int) 0 ;
3390 int arg2 = (int) 0 ;
3391 wxSize *result;
3392 PyObject * obj0 = 0 ;
3393 PyObject * obj1 = 0 ;
3394 char *kwnames[] = {
3395 (char *) "w",(char *) "h", NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3399 if (obj0) {
3400 {
3401 arg1 = (int)(SWIG_As_int(obj0));
3402 if (SWIG_arg_fail(1)) SWIG_fail;
3403 }
3404 }
3405 if (obj1) {
3406 {
3407 arg2 = (int)(SWIG_As_int(obj1));
3408 if (SWIG_arg_fail(2)) SWIG_fail;
3409 }
3410 }
3411 {
3412 PyThreadState* __tstate = wxPyBeginAllowThreads();
3413 result = (wxSize *)new wxSize(arg1,arg2);
3414
3415 wxPyEndAllowThreads(__tstate);
3416 if (PyErr_Occurred()) SWIG_fail;
3417 }
3418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3419 return resultobj;
3420 fail:
3421 return NULL;
3422 }
3423
3424
3425 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3426 PyObject *resultobj;
3427 wxSize *arg1 = (wxSize *) 0 ;
3428 PyObject * obj0 = 0 ;
3429 char *kwnames[] = {
3430 (char *) "self", NULL
3431 };
3432
3433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3435 if (SWIG_arg_fail(1)) SWIG_fail;
3436 {
3437 PyThreadState* __tstate = wxPyBeginAllowThreads();
3438 delete arg1;
3439
3440 wxPyEndAllowThreads(__tstate);
3441 if (PyErr_Occurred()) SWIG_fail;
3442 }
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 return resultobj;
3445 fail:
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxSize *arg1 = (wxSize *) 0 ;
3453 wxSize *arg2 = 0 ;
3454 bool result;
3455 wxSize temp2 ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self",(char *) "sz", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 arg2 = &temp2;
3467 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3468 }
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 {
3477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3478 }
3479 return resultobj;
3480 fail:
3481 return NULL;
3482 }
3483
3484
3485 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3486 PyObject *resultobj;
3487 wxSize *arg1 = (wxSize *) 0 ;
3488 wxSize *arg2 = 0 ;
3489 bool result;
3490 wxSize temp2 ;
3491 PyObject * obj0 = 0 ;
3492 PyObject * obj1 = 0 ;
3493 char *kwnames[] = {
3494 (char *) "self",(char *) "sz", NULL
3495 };
3496
3497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3499 if (SWIG_arg_fail(1)) SWIG_fail;
3500 {
3501 arg2 = &temp2;
3502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3503 }
3504 {
3505 PyThreadState* __tstate = wxPyBeginAllowThreads();
3506 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3507
3508 wxPyEndAllowThreads(__tstate);
3509 if (PyErr_Occurred()) SWIG_fail;
3510 }
3511 {
3512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3513 }
3514 return resultobj;
3515 fail:
3516 return NULL;
3517 }
3518
3519
3520 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3521 PyObject *resultobj;
3522 wxSize *arg1 = (wxSize *) 0 ;
3523 wxSize *arg2 = 0 ;
3524 wxSize result;
3525 wxSize temp2 ;
3526 PyObject * obj0 = 0 ;
3527 PyObject * obj1 = 0 ;
3528 char *kwnames[] = {
3529 (char *) "self",(char *) "sz", NULL
3530 };
3531
3532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3534 if (SWIG_arg_fail(1)) SWIG_fail;
3535 {
3536 arg2 = &temp2;
3537 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3538 }
3539 {
3540 PyThreadState* __tstate = wxPyBeginAllowThreads();
3541 result = (arg1)->operator +((wxSize const &)*arg2);
3542
3543 wxPyEndAllowThreads(__tstate);
3544 if (PyErr_Occurred()) SWIG_fail;
3545 }
3546 {
3547 wxSize * resultptr;
3548 resultptr = new wxSize((wxSize &)(result));
3549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxSize *arg1 = (wxSize *) 0 ;
3560 wxSize *arg2 = 0 ;
3561 wxSize result;
3562 wxSize temp2 ;
3563 PyObject * obj0 = 0 ;
3564 PyObject * obj1 = 0 ;
3565 char *kwnames[] = {
3566 (char *) "self",(char *) "sz", NULL
3567 };
3568
3569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(1)) SWIG_fail;
3572 {
3573 arg2 = &temp2;
3574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3575 }
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (arg1)->operator -((wxSize const &)*arg2);
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 {
3584 wxSize * resultptr;
3585 resultptr = new wxSize((wxSize &)(result));
3586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3587 }
3588 return resultobj;
3589 fail:
3590 return NULL;
3591 }
3592
3593
3594 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3595 PyObject *resultobj;
3596 wxSize *arg1 = (wxSize *) 0 ;
3597 wxSize *arg2 = 0 ;
3598 wxSize temp2 ;
3599 PyObject * obj0 = 0 ;
3600 PyObject * obj1 = 0 ;
3601 char *kwnames[] = {
3602 (char *) "self",(char *) "sz", NULL
3603 };
3604
3605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3607 if (SWIG_arg_fail(1)) SWIG_fail;
3608 {
3609 arg2 = &temp2;
3610 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3611 }
3612 {
3613 PyThreadState* __tstate = wxPyBeginAllowThreads();
3614 (arg1)->IncTo((wxSize const &)*arg2);
3615
3616 wxPyEndAllowThreads(__tstate);
3617 if (PyErr_Occurred()) SWIG_fail;
3618 }
3619 Py_INCREF(Py_None); resultobj = Py_None;
3620 return resultobj;
3621 fail:
3622 return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj;
3628 wxSize *arg1 = (wxSize *) 0 ;
3629 wxSize *arg2 = 0 ;
3630 wxSize temp2 ;
3631 PyObject * obj0 = 0 ;
3632 PyObject * obj1 = 0 ;
3633 char *kwnames[] = {
3634 (char *) "self",(char *) "sz", NULL
3635 };
3636
3637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3639 if (SWIG_arg_fail(1)) SWIG_fail;
3640 {
3641 arg2 = &temp2;
3642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3643 }
3644 {
3645 PyThreadState* __tstate = wxPyBeginAllowThreads();
3646 (arg1)->DecTo((wxSize const &)*arg2);
3647
3648 wxPyEndAllowThreads(__tstate);
3649 if (PyErr_Occurred()) SWIG_fail;
3650 }
3651 Py_INCREF(Py_None); resultobj = Py_None;
3652 return resultobj;
3653 fail:
3654 return NULL;
3655 }
3656
3657
3658 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3659 PyObject *resultobj;
3660 wxSize *arg1 = (wxSize *) 0 ;
3661 int arg2 ;
3662 int arg3 ;
3663 PyObject * obj0 = 0 ;
3664 PyObject * obj1 = 0 ;
3665 PyObject * obj2 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "self",(char *) "w",(char *) "h", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3672 if (SWIG_arg_fail(1)) SWIG_fail;
3673 {
3674 arg2 = (int)(SWIG_As_int(obj1));
3675 if (SWIG_arg_fail(2)) SWIG_fail;
3676 }
3677 {
3678 arg3 = (int)(SWIG_As_int(obj2));
3679 if (SWIG_arg_fail(3)) SWIG_fail;
3680 }
3681 {
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 (arg1)->Set(arg2,arg3);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 Py_INCREF(Py_None); resultobj = Py_None;
3689 return resultobj;
3690 fail:
3691 return NULL;
3692 }
3693
3694
3695 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3696 PyObject *resultobj;
3697 wxSize *arg1 = (wxSize *) 0 ;
3698 int arg2 ;
3699 PyObject * obj0 = 0 ;
3700 PyObject * obj1 = 0 ;
3701 char *kwnames[] = {
3702 (char *) "self",(char *) "w", NULL
3703 };
3704
3705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3707 if (SWIG_arg_fail(1)) SWIG_fail;
3708 {
3709 arg2 = (int)(SWIG_As_int(obj1));
3710 if (SWIG_arg_fail(2)) SWIG_fail;
3711 }
3712 {
3713 PyThreadState* __tstate = wxPyBeginAllowThreads();
3714 (arg1)->SetWidth(arg2);
3715
3716 wxPyEndAllowThreads(__tstate);
3717 if (PyErr_Occurred()) SWIG_fail;
3718 }
3719 Py_INCREF(Py_None); resultobj = Py_None;
3720 return resultobj;
3721 fail:
3722 return NULL;
3723 }
3724
3725
3726 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3727 PyObject *resultobj;
3728 wxSize *arg1 = (wxSize *) 0 ;
3729 int arg2 ;
3730 PyObject * obj0 = 0 ;
3731 PyObject * obj1 = 0 ;
3732 char *kwnames[] = {
3733 (char *) "self",(char *) "h", NULL
3734 };
3735
3736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3738 if (SWIG_arg_fail(1)) SWIG_fail;
3739 {
3740 arg2 = (int)(SWIG_As_int(obj1));
3741 if (SWIG_arg_fail(2)) SWIG_fail;
3742 }
3743 {
3744 PyThreadState* __tstate = wxPyBeginAllowThreads();
3745 (arg1)->SetHeight(arg2);
3746
3747 wxPyEndAllowThreads(__tstate);
3748 if (PyErr_Occurred()) SWIG_fail;
3749 }
3750 Py_INCREF(Py_None); resultobj = Py_None;
3751 return resultobj;
3752 fail:
3753 return NULL;
3754 }
3755
3756
3757 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3758 PyObject *resultobj;
3759 wxSize *arg1 = (wxSize *) 0 ;
3760 int result;
3761 PyObject * obj0 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (int)((wxSize const *)arg1)->GetWidth();
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = SWIG_From_int((int)(result));
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 wxSize *arg1 = (wxSize *) 0 ;
3788 int result;
3789 PyObject * obj0 = 0 ;
3790 char *kwnames[] = {
3791 (char *) "self", NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3796 if (SWIG_arg_fail(1)) SWIG_fail;
3797 {
3798 PyThreadState* __tstate = wxPyBeginAllowThreads();
3799 result = (int)((wxSize const *)arg1)->GetHeight();
3800
3801 wxPyEndAllowThreads(__tstate);
3802 if (PyErr_Occurred()) SWIG_fail;
3803 }
3804 {
3805 resultobj = SWIG_From_int((int)(result));
3806 }
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 bool result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 wxSize *arg2 = 0 ;
3845 wxSize temp2 ;
3846 PyObject * obj0 = 0 ;
3847 PyObject * obj1 = 0 ;
3848 char *kwnames[] = {
3849 (char *) "self",(char *) "size", NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3854 if (SWIG_arg_fail(1)) SWIG_fail;
3855 {
3856 arg2 = &temp2;
3857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3858 }
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 (arg1)->SetDefaults((wxSize const &)*arg2);
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 Py_INCREF(Py_None); resultobj = Py_None;
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj;
3875 wxSize *arg1 = (wxSize *) 0 ;
3876 PyObject *result;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 result = (PyObject *)wxSize_Get(arg1);
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 resultobj = result;
3893 return resultobj;
3894 fail:
3895 return NULL;
3896 }
3897
3898
3899 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3900 PyObject *obj;
3901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3902 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3903 Py_INCREF(obj);
3904 return Py_BuildValue((char *)"");
3905 }
3906 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3907 PyObject *resultobj;
3908 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3909 double arg2 ;
3910 PyObject * obj0 = 0 ;
3911 PyObject * obj1 = 0 ;
3912 char *kwnames[] = {
3913 (char *) "self",(char *) "x", NULL
3914 };
3915
3916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3918 if (SWIG_arg_fail(1)) SWIG_fail;
3919 {
3920 arg2 = (double)(SWIG_As_double(obj1));
3921 if (SWIG_arg_fail(2)) SWIG_fail;
3922 }
3923 if (arg1) (arg1)->x = arg2;
3924
3925 Py_INCREF(Py_None); resultobj = Py_None;
3926 return resultobj;
3927 fail:
3928 return NULL;
3929 }
3930
3931
3932 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3933 PyObject *resultobj;
3934 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3935 double result;
3936 PyObject * obj0 = 0 ;
3937 char *kwnames[] = {
3938 (char *) "self", NULL
3939 };
3940
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3943 if (SWIG_arg_fail(1)) SWIG_fail;
3944 result = (double) ((arg1)->x);
3945
3946 {
3947 resultobj = SWIG_From_double((double)(result));
3948 }
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3956 PyObject *resultobj;
3957 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3958 double arg2 ;
3959 PyObject * obj0 = 0 ;
3960 PyObject * obj1 = 0 ;
3961 char *kwnames[] = {
3962 (char *) "self",(char *) "y", NULL
3963 };
3964
3965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3967 if (SWIG_arg_fail(1)) SWIG_fail;
3968 {
3969 arg2 = (double)(SWIG_As_double(obj1));
3970 if (SWIG_arg_fail(2)) SWIG_fail;
3971 }
3972 if (arg1) (arg1)->y = arg2;
3973
3974 Py_INCREF(Py_None); resultobj = Py_None;
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3984 double result;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 result = (double) ((arg1)->y);
3994
3995 {
3996 resultobj = SWIG_From_double((double)(result));
3997 }
3998 return resultobj;
3999 fail:
4000 return NULL;
4001 }
4002
4003
4004 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4005 PyObject *resultobj;
4006 double arg1 = (double) 0.0 ;
4007 double arg2 = (double) 0.0 ;
4008 wxRealPoint *result;
4009 PyObject * obj0 = 0 ;
4010 PyObject * obj1 = 0 ;
4011 char *kwnames[] = {
4012 (char *) "x",(char *) "y", NULL
4013 };
4014
4015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4016 if (obj0) {
4017 {
4018 arg1 = (double)(SWIG_As_double(obj0));
4019 if (SWIG_arg_fail(1)) SWIG_fail;
4020 }
4021 }
4022 if (obj1) {
4023 {
4024 arg2 = (double)(SWIG_As_double(obj1));
4025 if (SWIG_arg_fail(2)) SWIG_fail;
4026 }
4027 }
4028 {
4029 PyThreadState* __tstate = wxPyBeginAllowThreads();
4030 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4031
4032 wxPyEndAllowThreads(__tstate);
4033 if (PyErr_Occurred()) SWIG_fail;
4034 }
4035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4036 return resultobj;
4037 fail:
4038 return NULL;
4039 }
4040
4041
4042 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4043 PyObject *resultobj;
4044 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4045 PyObject * obj0 = 0 ;
4046 char *kwnames[] = {
4047 (char *) "self", NULL
4048 };
4049
4050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4052 if (SWIG_arg_fail(1)) SWIG_fail;
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 delete arg1;
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4070 wxRealPoint *arg2 = 0 ;
4071 bool result;
4072 wxRealPoint temp2 ;
4073 PyObject * obj0 = 0 ;
4074 PyObject * obj1 = 0 ;
4075 char *kwnames[] = {
4076 (char *) "self",(char *) "pt", NULL
4077 };
4078
4079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 {
4083 arg2 = &temp2;
4084 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4085 }
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4089
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 {
4094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4095 }
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4105 wxRealPoint *arg2 = 0 ;
4106 bool result;
4107 wxRealPoint temp2 ;
4108 PyObject * obj0 = 0 ;
4109 PyObject * obj1 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "self",(char *) "pt", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4116 if (SWIG_arg_fail(1)) SWIG_fail;
4117 {
4118 arg2 = &temp2;
4119 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 {
4129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4130 }
4131 return resultobj;
4132 fail:
4133 return NULL;
4134 }
4135
4136
4137 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4138 PyObject *resultobj;
4139 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4140 wxRealPoint *arg2 = 0 ;
4141 wxRealPoint result;
4142 wxRealPoint temp2 ;
4143 PyObject * obj0 = 0 ;
4144 PyObject * obj1 = 0 ;
4145 char *kwnames[] = {
4146 (char *) "self",(char *) "pt", NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4151 if (SWIG_arg_fail(1)) SWIG_fail;
4152 {
4153 arg2 = &temp2;
4154 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4155 }
4156 {
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4159
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 {
4164 wxRealPoint * resultptr;
4165 resultptr = new wxRealPoint((wxRealPoint &)(result));
4166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4167 }
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4175 PyObject *resultobj;
4176 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4177 wxRealPoint *arg2 = 0 ;
4178 wxRealPoint result;
4179 wxRealPoint temp2 ;
4180 PyObject * obj0 = 0 ;
4181 PyObject * obj1 = 0 ;
4182 char *kwnames[] = {
4183 (char *) "self",(char *) "pt", NULL
4184 };
4185
4186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4188 if (SWIG_arg_fail(1)) SWIG_fail;
4189 {
4190 arg2 = &temp2;
4191 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4192 }
4193 {
4194 PyThreadState* __tstate = wxPyBeginAllowThreads();
4195 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4196
4197 wxPyEndAllowThreads(__tstate);
4198 if (PyErr_Occurred()) SWIG_fail;
4199 }
4200 {
4201 wxRealPoint * resultptr;
4202 resultptr = new wxRealPoint((wxRealPoint &)(result));
4203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4204 }
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj;
4213 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4214 double arg2 ;
4215 double arg3 ;
4216 PyObject * obj0 = 0 ;
4217 PyObject * obj1 = 0 ;
4218 PyObject * obj2 = 0 ;
4219 char *kwnames[] = {
4220 (char *) "self",(char *) "x",(char *) "y", NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4225 if (SWIG_arg_fail(1)) SWIG_fail;
4226 {
4227 arg2 = (double)(SWIG_As_double(obj1));
4228 if (SWIG_arg_fail(2)) SWIG_fail;
4229 }
4230 {
4231 arg3 = (double)(SWIG_As_double(obj2));
4232 if (SWIG_arg_fail(3)) SWIG_fail;
4233 }
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 wxRealPoint_Set(arg1,arg2,arg3);
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 Py_INCREF(Py_None); resultobj = Py_None;
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj;
4250 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4251 PyObject *result;
4252 PyObject * obj0 = 0 ;
4253 char *kwnames[] = {
4254 (char *) "self", NULL
4255 };
4256
4257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = (PyObject *)wxRealPoint_Get(arg1);
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 resultobj = result;
4268 return resultobj;
4269 fail:
4270 return NULL;
4271 }
4272
4273
4274 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4275 PyObject *obj;
4276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4277 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4278 Py_INCREF(obj);
4279 return Py_BuildValue((char *)"");
4280 }
4281 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxPoint *arg1 = (wxPoint *) 0 ;
4284 int arg2 ;
4285 PyObject * obj0 = 0 ;
4286 PyObject * obj1 = 0 ;
4287 char *kwnames[] = {
4288 (char *) "self",(char *) "x", NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4293 if (SWIG_arg_fail(1)) SWIG_fail;
4294 {
4295 arg2 = (int)(SWIG_As_int(obj1));
4296 if (SWIG_arg_fail(2)) SWIG_fail;
4297 }
4298 if (arg1) (arg1)->x = arg2;
4299
4300 Py_INCREF(Py_None); resultobj = Py_None;
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxPoint *arg1 = (wxPoint *) 0 ;
4310 int result;
4311 PyObject * obj0 = 0 ;
4312 char *kwnames[] = {
4313 (char *) "self", NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4318 if (SWIG_arg_fail(1)) SWIG_fail;
4319 result = (int) ((arg1)->x);
4320
4321 {
4322 resultobj = SWIG_From_int((int)(result));
4323 }
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj;
4332 wxPoint *arg1 = (wxPoint *) 0 ;
4333 int arg2 ;
4334 PyObject * obj0 = 0 ;
4335 PyObject * obj1 = 0 ;
4336 char *kwnames[] = {
4337 (char *) "self",(char *) "y", NULL
4338 };
4339
4340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4342 if (SWIG_arg_fail(1)) SWIG_fail;
4343 {
4344 arg2 = (int)(SWIG_As_int(obj1));
4345 if (SWIG_arg_fail(2)) SWIG_fail;
4346 }
4347 if (arg1) (arg1)->y = arg2;
4348
4349 Py_INCREF(Py_None); resultobj = Py_None;
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj;
4358 wxPoint *arg1 = (wxPoint *) 0 ;
4359 int result;
4360 PyObject * obj0 = 0 ;
4361 char *kwnames[] = {
4362 (char *) "self", NULL
4363 };
4364
4365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4367 if (SWIG_arg_fail(1)) SWIG_fail;
4368 result = (int) ((arg1)->y);
4369
4370 {
4371 resultobj = SWIG_From_int((int)(result));
4372 }
4373 return resultobj;
4374 fail:
4375 return NULL;
4376 }
4377
4378
4379 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4380 PyObject *resultobj;
4381 int arg1 = (int) 0 ;
4382 int arg2 = (int) 0 ;
4383 wxPoint *result;
4384 PyObject * obj0 = 0 ;
4385 PyObject * obj1 = 0 ;
4386 char *kwnames[] = {
4387 (char *) "x",(char *) "y", NULL
4388 };
4389
4390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4391 if (obj0) {
4392 {
4393 arg1 = (int)(SWIG_As_int(obj0));
4394 if (SWIG_arg_fail(1)) SWIG_fail;
4395 }
4396 }
4397 if (obj1) {
4398 {
4399 arg2 = (int)(SWIG_As_int(obj1));
4400 if (SWIG_arg_fail(2)) SWIG_fail;
4401 }
4402 }
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = (wxPoint *)new wxPoint(arg1,arg2);
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4411 return resultobj;
4412 fail:
4413 return NULL;
4414 }
4415
4416
4417 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4418 PyObject *resultobj;
4419 wxPoint *arg1 = (wxPoint *) 0 ;
4420 PyObject * obj0 = 0 ;
4421 char *kwnames[] = {
4422 (char *) "self", NULL
4423 };
4424
4425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4427 if (SWIG_arg_fail(1)) SWIG_fail;
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 delete arg1;
4431
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 Py_INCREF(Py_None); resultobj = Py_None;
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj;
4444 wxPoint *arg1 = (wxPoint *) 0 ;
4445 wxPoint *arg2 = 0 ;
4446 bool result;
4447 wxPoint temp2 ;
4448 PyObject * obj0 = 0 ;
4449 PyObject * obj1 = 0 ;
4450 char *kwnames[] = {
4451 (char *) "self",(char *) "pt", NULL
4452 };
4453
4454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4456 if (SWIG_arg_fail(1)) SWIG_fail;
4457 {
4458 arg2 = &temp2;
4459 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4460 }
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 {
4469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4470 }
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj;
4479 wxPoint *arg1 = (wxPoint *) 0 ;
4480 wxPoint *arg2 = 0 ;
4481 bool result;
4482 wxPoint temp2 ;
4483 PyObject * obj0 = 0 ;
4484 PyObject * obj1 = 0 ;
4485 char *kwnames[] = {
4486 (char *) "self",(char *) "pt", NULL
4487 };
4488
4489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4491 if (SWIG_arg_fail(1)) SWIG_fail;
4492 {
4493 arg2 = &temp2;
4494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4495 }
4496 {
4497 PyThreadState* __tstate = wxPyBeginAllowThreads();
4498 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4499
4500 wxPyEndAllowThreads(__tstate);
4501 if (PyErr_Occurred()) SWIG_fail;
4502 }
4503 {
4504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4505 }
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4513 PyObject *resultobj;
4514 wxPoint *arg1 = (wxPoint *) 0 ;
4515 wxPoint *arg2 = 0 ;
4516 wxPoint result;
4517 wxPoint temp2 ;
4518 PyObject * obj0 = 0 ;
4519 PyObject * obj1 = 0 ;
4520 char *kwnames[] = {
4521 (char *) "self",(char *) "pt", NULL
4522 };
4523
4524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4526 if (SWIG_arg_fail(1)) SWIG_fail;
4527 {
4528 arg2 = &temp2;
4529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (arg1)->operator +((wxPoint const &)*arg2);
4534
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 wxPoint * resultptr;
4540 resultptr = new wxPoint((wxPoint &)(result));
4541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4542 }
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4550 PyObject *resultobj;
4551 wxPoint *arg1 = (wxPoint *) 0 ;
4552 wxPoint *arg2 = 0 ;
4553 wxPoint result;
4554 wxPoint temp2 ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 char *kwnames[] = {
4558 (char *) "self",(char *) "pt", NULL
4559 };
4560
4561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4563 if (SWIG_arg_fail(1)) SWIG_fail;
4564 {
4565 arg2 = &temp2;
4566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = (arg1)->operator -((wxPoint const &)*arg2);
4571
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 {
4576 wxPoint * resultptr;
4577 resultptr = new wxPoint((wxPoint &)(result));
4578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4579 }
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj;
4588 wxPoint *arg1 = (wxPoint *) 0 ;
4589 wxPoint *arg2 = 0 ;
4590 wxPoint *result;
4591 wxPoint temp2 ;
4592 PyObject * obj0 = 0 ;
4593 PyObject * obj1 = 0 ;
4594 char *kwnames[] = {
4595 (char *) "self",(char *) "pt", NULL
4596 };
4597
4598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4600 if (SWIG_arg_fail(1)) SWIG_fail;
4601 {
4602 arg2 = &temp2;
4603 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4604 }
4605 {
4606 PyThreadState* __tstate = wxPyBeginAllowThreads();
4607 {
4608 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4609 result = (wxPoint *) &_result_ref;
4610 }
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj;
4624 wxPoint *arg1 = (wxPoint *) 0 ;
4625 wxPoint *arg2 = 0 ;
4626 wxPoint *result;
4627 wxPoint temp2 ;
4628 PyObject * obj0 = 0 ;
4629 PyObject * obj1 = 0 ;
4630 char *kwnames[] = {
4631 (char *) "self",(char *) "pt", NULL
4632 };
4633
4634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4636 if (SWIG_arg_fail(1)) SWIG_fail;
4637 {
4638 arg2 = &temp2;
4639 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4640 }
4641 {
4642 PyThreadState* __tstate = wxPyBeginAllowThreads();
4643 {
4644 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4645 result = (wxPoint *) &_result_ref;
4646 }
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxPoint *arg1 = (wxPoint *) 0 ;
4661 long arg2 ;
4662 long arg3 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 PyObject * obj2 = 0 ;
4666 char *kwnames[] = {
4667 (char *) "self",(char *) "x",(char *) "y", NULL
4668 };
4669
4670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4672 if (SWIG_arg_fail(1)) SWIG_fail;
4673 {
4674 arg2 = (long)(SWIG_As_long(obj1));
4675 if (SWIG_arg_fail(2)) SWIG_fail;
4676 }
4677 {
4678 arg3 = (long)(SWIG_As_long(obj2));
4679 if (SWIG_arg_fail(3)) SWIG_fail;
4680 }
4681 {
4682 PyThreadState* __tstate = wxPyBeginAllowThreads();
4683 wxPoint_Set(arg1,arg2,arg3);
4684
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 Py_INCREF(Py_None); resultobj = Py_None;
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4696 PyObject *resultobj;
4697 wxPoint *arg1 = (wxPoint *) 0 ;
4698 PyObject *result;
4699 PyObject * obj0 = 0 ;
4700 char *kwnames[] = {
4701 (char *) "self", NULL
4702 };
4703
4704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4706 if (SWIG_arg_fail(1)) SWIG_fail;
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 result = (PyObject *)wxPoint_Get(arg1);
4710
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = result;
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4722 PyObject *obj;
4723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4724 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4725 Py_INCREF(obj);
4726 return Py_BuildValue((char *)"");
4727 }
4728 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4729 PyObject *resultobj;
4730 int arg1 = (int) 0 ;
4731 int arg2 = (int) 0 ;
4732 int arg3 = (int) 0 ;
4733 int arg4 = (int) 0 ;
4734 wxRect *result;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 PyObject * obj2 = 0 ;
4738 PyObject * obj3 = 0 ;
4739 char *kwnames[] = {
4740 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4741 };
4742
4743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4744 if (obj0) {
4745 {
4746 arg1 = (int)(SWIG_As_int(obj0));
4747 if (SWIG_arg_fail(1)) SWIG_fail;
4748 }
4749 }
4750 if (obj1) {
4751 {
4752 arg2 = (int)(SWIG_As_int(obj1));
4753 if (SWIG_arg_fail(2)) SWIG_fail;
4754 }
4755 }
4756 if (obj2) {
4757 {
4758 arg3 = (int)(SWIG_As_int(obj2));
4759 if (SWIG_arg_fail(3)) SWIG_fail;
4760 }
4761 }
4762 if (obj3) {
4763 {
4764 arg4 = (int)(SWIG_As_int(obj3));
4765 if (SWIG_arg_fail(4)) SWIG_fail;
4766 }
4767 }
4768 {
4769 PyThreadState* __tstate = wxPyBeginAllowThreads();
4770 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4771
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj;
4784 wxPoint *arg1 = 0 ;
4785 wxPoint *arg2 = 0 ;
4786 wxRect *result;
4787 wxPoint temp1 ;
4788 wxPoint temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "topLeft",(char *) "bottomRight", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4796 {
4797 arg1 = &temp1;
4798 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4799 }
4800 {
4801 arg2 = &temp2;
4802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4803 }
4804 {
4805 PyThreadState* __tstate = wxPyBeginAllowThreads();
4806 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj;
4820 wxPoint *arg1 = 0 ;
4821 wxSize *arg2 = 0 ;
4822 wxRect *result;
4823 wxPoint temp1 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "pos",(char *) "size", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4832 {
4833 arg1 = &temp1;
4834 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4835 }
4836 {
4837 arg2 = &temp2;
4838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4839 }
4840 {
4841 PyThreadState* __tstate = wxPyBeginAllowThreads();
4842 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj;
4856 wxSize *arg1 = 0 ;
4857 wxRect *result;
4858 wxSize temp1 ;
4859 PyObject * obj0 = 0 ;
4860 char *kwnames[] = {
4861 (char *) "size", NULL
4862 };
4863
4864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4865 {
4866 arg1 = &temp1;
4867 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4868 }
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4872
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxRect *arg1 = (wxRect *) 0 ;
4886 PyObject * obj0 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "self", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(1)) SWIG_fail;
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 delete arg1;
4897
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 Py_INCREF(Py_None); resultobj = Py_None;
4902 return resultobj;
4903 fail:
4904 return NULL;
4905 }
4906
4907
4908 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj;
4910 wxRect *arg1 = (wxRect *) 0 ;
4911 int result;
4912 PyObject * obj0 = 0 ;
4913 char *kwnames[] = {
4914 (char *) "self", NULL
4915 };
4916
4917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4919 if (SWIG_arg_fail(1)) SWIG_fail;
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = (int)((wxRect const *)arg1)->GetX();
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 {
4928 resultobj = SWIG_From_int((int)(result));
4929 }
4930 return resultobj;
4931 fail:
4932 return NULL;
4933 }
4934
4935
4936 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj;
4938 wxRect *arg1 = (wxRect *) 0 ;
4939 int arg2 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 char *kwnames[] = {
4943 (char *) "self",(char *) "x", NULL
4944 };
4945
4946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4948 if (SWIG_arg_fail(1)) SWIG_fail;
4949 {
4950 arg2 = (int)(SWIG_As_int(obj1));
4951 if (SWIG_arg_fail(2)) SWIG_fail;
4952 }
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->SetX(arg2);
4956
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 Py_INCREF(Py_None); resultobj = Py_None;
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj;
4969 wxRect *arg1 = (wxRect *) 0 ;
4970 int result;
4971 PyObject * obj0 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "self", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4978 if (SWIG_arg_fail(1)) SWIG_fail;
4979 {
4980 PyThreadState* __tstate = wxPyBeginAllowThreads();
4981 result = (int)(arg1)->GetY();
4982
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 resultobj = SWIG_From_int((int)(result));
4988 }
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj;
4997 wxRect *arg1 = (wxRect *) 0 ;
4998 int arg2 ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "self",(char *) "y", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5007 if (SWIG_arg_fail(1)) SWIG_fail;
5008 {
5009 arg2 = (int)(SWIG_As_int(obj1));
5010 if (SWIG_arg_fail(2)) SWIG_fail;
5011 }
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 (arg1)->SetY(arg2);
5015
5016 wxPyEndAllowThreads(__tstate);
5017 if (PyErr_Occurred()) SWIG_fail;
5018 }
5019 Py_INCREF(Py_None); resultobj = Py_None;
5020 return resultobj;
5021 fail:
5022 return NULL;
5023 }
5024
5025
5026 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj;
5028 wxRect *arg1 = (wxRect *) 0 ;
5029 int result;
5030 PyObject * obj0 = 0 ;
5031 char *kwnames[] = {
5032 (char *) "self", NULL
5033 };
5034
5035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(1)) SWIG_fail;
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = (int)((wxRect const *)arg1)->GetWidth();
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = SWIG_From_int((int)(result));
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxRect *arg1 = (wxRect *) 0 ;
5057 int arg2 ;
5058 PyObject * obj0 = 0 ;
5059 PyObject * obj1 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "self",(char *) "w", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 {
5068 arg2 = (int)(SWIG_As_int(obj1));
5069 if (SWIG_arg_fail(2)) SWIG_fail;
5070 }
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 (arg1)->SetWidth(arg2);
5074
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 Py_INCREF(Py_None); resultobj = Py_None;
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxRect *arg1 = (wxRect *) 0 ;
5088 int result;
5089 PyObject * obj0 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "self", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(1)) SWIG_fail;
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (int)((wxRect const *)arg1)->GetHeight();
5100
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 {
5105 resultobj = SWIG_From_int((int)(result));
5106 }
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5114 PyObject *resultobj;
5115 wxRect *arg1 = (wxRect *) 0 ;
5116 int arg2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self",(char *) "h", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 arg2 = (int)(SWIG_As_int(obj1));
5128 if (SWIG_arg_fail(2)) SWIG_fail;
5129 }
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 (arg1)->SetHeight(arg2);
5133
5134 wxPyEndAllowThreads(__tstate);
5135 if (PyErr_Occurred()) SWIG_fail;
5136 }
5137 Py_INCREF(Py_None); resultobj = Py_None;
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 wxRect *arg1 = (wxRect *) 0 ;
5147 wxPoint result;
5148 PyObject * obj0 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "self", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5155 if (SWIG_arg_fail(1)) SWIG_fail;
5156 {
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = ((wxRect const *)arg1)->GetPosition();
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 {
5164 wxPoint * resultptr;
5165 resultptr = new wxPoint((wxPoint &)(result));
5166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5167 }
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5175 PyObject *resultobj;
5176 wxRect *arg1 = (wxRect *) 0 ;
5177 wxPoint *arg2 = 0 ;
5178 wxPoint temp2 ;
5179 PyObject * obj0 = 0 ;
5180 PyObject * obj1 = 0 ;
5181 char *kwnames[] = {
5182 (char *) "self",(char *) "p", NULL
5183 };
5184
5185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5187 if (SWIG_arg_fail(1)) SWIG_fail;
5188 {
5189 arg2 = &temp2;
5190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5191 }
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 (arg1)->SetPosition((wxPoint const &)*arg2);
5195
5196 wxPyEndAllowThreads(__tstate);
5197 if (PyErr_Occurred()) SWIG_fail;
5198 }
5199 Py_INCREF(Py_None); resultobj = Py_None;
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj;
5208 wxRect *arg1 = (wxRect *) 0 ;
5209 wxSize result;
5210 PyObject * obj0 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "self", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5217 if (SWIG_arg_fail(1)) SWIG_fail;
5218 {
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = ((wxRect const *)arg1)->GetSize();
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 {
5226 wxSize * resultptr;
5227 resultptr = new wxSize((wxSize &)(result));
5228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5229 }
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj;
5238 wxRect *arg1 = (wxRect *) 0 ;
5239 wxSize *arg2 = 0 ;
5240 wxSize temp2 ;
5241 PyObject * obj0 = 0 ;
5242 PyObject * obj1 = 0 ;
5243 char *kwnames[] = {
5244 (char *) "self",(char *) "s", NULL
5245 };
5246
5247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5249 if (SWIG_arg_fail(1)) SWIG_fail;
5250 {
5251 arg2 = &temp2;
5252 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5253 }
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 (arg1)->SetSize((wxSize const &)*arg2);
5257
5258 wxPyEndAllowThreads(__tstate);
5259 if (PyErr_Occurred()) SWIG_fail;
5260 }
5261 Py_INCREF(Py_None); resultobj = Py_None;
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5269 PyObject *resultobj;
5270 wxRect *arg1 = (wxRect *) 0 ;
5271 wxPoint result;
5272 PyObject * obj0 = 0 ;
5273 char *kwnames[] = {
5274 (char *) "self", NULL
5275 };
5276
5277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5279 if (SWIG_arg_fail(1)) SWIG_fail;
5280 {
5281 PyThreadState* __tstate = wxPyBeginAllowThreads();
5282 result = ((wxRect const *)arg1)->GetTopLeft();
5283
5284 wxPyEndAllowThreads(__tstate);
5285 if (PyErr_Occurred()) SWIG_fail;
5286 }
5287 {
5288 wxPoint * resultptr;
5289 resultptr = new wxPoint((wxPoint &)(result));
5290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5291 }
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 wxPoint *arg2 = 0 ;
5302 wxPoint temp2 ;
5303 PyObject * obj0 = 0 ;
5304 PyObject * obj1 = 0 ;
5305 char *kwnames[] = {
5306 (char *) "self",(char *) "p", NULL
5307 };
5308
5309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5311 if (SWIG_arg_fail(1)) SWIG_fail;
5312 {
5313 arg2 = &temp2;
5314 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5315 }
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5319
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 Py_INCREF(Py_None); resultobj = Py_None;
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5331 PyObject *resultobj;
5332 wxRect *arg1 = (wxRect *) 0 ;
5333 wxPoint result;
5334 PyObject * obj0 = 0 ;
5335 char *kwnames[] = {
5336 (char *) "self", NULL
5337 };
5338
5339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5341 if (SWIG_arg_fail(1)) SWIG_fail;
5342 {
5343 PyThreadState* __tstate = wxPyBeginAllowThreads();
5344 result = ((wxRect const *)arg1)->GetBottomRight();
5345
5346 wxPyEndAllowThreads(__tstate);
5347 if (PyErr_Occurred()) SWIG_fail;
5348 }
5349 {
5350 wxPoint * resultptr;
5351 resultptr = new wxPoint((wxPoint &)(result));
5352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5361 PyObject *resultobj;
5362 wxRect *arg1 = (wxRect *) 0 ;
5363 wxPoint *arg2 = 0 ;
5364 wxPoint temp2 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char *kwnames[] = {
5368 (char *) "self",(char *) "p", NULL
5369 };
5370
5371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5373 if (SWIG_arg_fail(1)) SWIG_fail;
5374 {
5375 arg2 = &temp2;
5376 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5377 }
5378 {
5379 PyThreadState* __tstate = wxPyBeginAllowThreads();
5380 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5381
5382 wxPyEndAllowThreads(__tstate);
5383 if (PyErr_Occurred()) SWIG_fail;
5384 }
5385 Py_INCREF(Py_None); resultobj = Py_None;
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj;
5394 wxRect *arg1 = (wxRect *) 0 ;
5395 int result;
5396 PyObject * obj0 = 0 ;
5397 char *kwnames[] = {
5398 (char *) "self", NULL
5399 };
5400
5401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5403 if (SWIG_arg_fail(1)) SWIG_fail;
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = (int)((wxRect const *)arg1)->GetLeft();
5407
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 resultobj = SWIG_From_int((int)(result));
5413 }
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5421 PyObject *resultobj;
5422 wxRect *arg1 = (wxRect *) 0 ;
5423 int result;
5424 PyObject * obj0 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (int)((wxRect const *)arg1)->GetTop();
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 resultobj = SWIG_From_int((int)(result));
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5449 PyObject *resultobj;
5450 wxRect *arg1 = (wxRect *) 0 ;
5451 int result;
5452 PyObject * obj0 = 0 ;
5453 char *kwnames[] = {
5454 (char *) "self", NULL
5455 };
5456
5457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5459 if (SWIG_arg_fail(1)) SWIG_fail;
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 result = (int)((wxRect const *)arg1)->GetBottom();
5463
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 resultobj = SWIG_From_int((int)(result));
5469 }
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj;
5478 wxRect *arg1 = (wxRect *) 0 ;
5479 int result;
5480 PyObject * obj0 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5487 if (SWIG_arg_fail(1)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (int)((wxRect const *)arg1)->GetRight();
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = SWIG_From_int((int)(result));
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int arg2 ;
5508 PyObject * obj0 = 0 ;
5509 PyObject * obj1 = 0 ;
5510 char *kwnames[] = {
5511 (char *) "self",(char *) "left", NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5516 if (SWIG_arg_fail(1)) SWIG_fail;
5517 {
5518 arg2 = (int)(SWIG_As_int(obj1));
5519 if (SWIG_arg_fail(2)) SWIG_fail;
5520 }
5521 {
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 (arg1)->SetLeft(arg2);
5524
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 Py_INCREF(Py_None); resultobj = Py_None;
5529 return resultobj;
5530 fail:
5531 return NULL;
5532 }
5533
5534
5535 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5536 PyObject *resultobj;
5537 wxRect *arg1 = (wxRect *) 0 ;
5538 int arg2 ;
5539 PyObject * obj0 = 0 ;
5540 PyObject * obj1 = 0 ;
5541 char *kwnames[] = {
5542 (char *) "self",(char *) "right", NULL
5543 };
5544
5545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5547 if (SWIG_arg_fail(1)) SWIG_fail;
5548 {
5549 arg2 = (int)(SWIG_As_int(obj1));
5550 if (SWIG_arg_fail(2)) SWIG_fail;
5551 }
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 (arg1)->SetRight(arg2);
5555
5556 wxPyEndAllowThreads(__tstate);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 Py_INCREF(Py_None); resultobj = Py_None;
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5567 PyObject *resultobj;
5568 wxRect *arg1 = (wxRect *) 0 ;
5569 int arg2 ;
5570 PyObject * obj0 = 0 ;
5571 PyObject * obj1 = 0 ;
5572 char *kwnames[] = {
5573 (char *) "self",(char *) "top", NULL
5574 };
5575
5576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5578 if (SWIG_arg_fail(1)) SWIG_fail;
5579 {
5580 arg2 = (int)(SWIG_As_int(obj1));
5581 if (SWIG_arg_fail(2)) SWIG_fail;
5582 }
5583 {
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 (arg1)->SetTop(arg2);
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 Py_INCREF(Py_None); resultobj = Py_None;
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj;
5599 wxRect *arg1 = (wxRect *) 0 ;
5600 int arg2 ;
5601 PyObject * obj0 = 0 ;
5602 PyObject * obj1 = 0 ;
5603 char *kwnames[] = {
5604 (char *) "self",(char *) "bottom", NULL
5605 };
5606
5607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5609 if (SWIG_arg_fail(1)) SWIG_fail;
5610 {
5611 arg2 = (int)(SWIG_As_int(obj1));
5612 if (SWIG_arg_fail(2)) SWIG_fail;
5613 }
5614 {
5615 PyThreadState* __tstate = wxPyBeginAllowThreads();
5616 (arg1)->SetBottom(arg2);
5617
5618 wxPyEndAllowThreads(__tstate);
5619 if (PyErr_Occurred()) SWIG_fail;
5620 }
5621 Py_INCREF(Py_None); resultobj = Py_None;
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj;
5630 wxRect *arg1 = (wxRect *) 0 ;
5631 int arg2 ;
5632 int arg3 ;
5633 wxRect *result;
5634 PyObject * obj0 = 0 ;
5635 PyObject * obj1 = 0 ;
5636 PyObject * obj2 = 0 ;
5637 char *kwnames[] = {
5638 (char *) "self",(char *) "dx",(char *) "dy", NULL
5639 };
5640
5641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5643 if (SWIG_arg_fail(1)) SWIG_fail;
5644 {
5645 arg2 = (int)(SWIG_As_int(obj1));
5646 if (SWIG_arg_fail(2)) SWIG_fail;
5647 }
5648 {
5649 arg3 = (int)(SWIG_As_int(obj2));
5650 if (SWIG_arg_fail(3)) SWIG_fail;
5651 }
5652 {
5653 PyThreadState* __tstate = wxPyBeginAllowThreads();
5654 {
5655 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5656 result = (wxRect *) &_result_ref;
5657 }
5658
5659 wxPyEndAllowThreads(__tstate);
5660 if (PyErr_Occurred()) SWIG_fail;
5661 }
5662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5670 PyObject *resultobj;
5671 wxRect *arg1 = (wxRect *) 0 ;
5672 int arg2 ;
5673 int arg3 ;
5674 wxRect *result;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 PyObject * obj2 = 0 ;
5678 char *kwnames[] = {
5679 (char *) "self",(char *) "dx",(char *) "dy", NULL
5680 };
5681
5682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5684 if (SWIG_arg_fail(1)) SWIG_fail;
5685 {
5686 arg2 = (int)(SWIG_As_int(obj1));
5687 if (SWIG_arg_fail(2)) SWIG_fail;
5688 }
5689 {
5690 arg3 = (int)(SWIG_As_int(obj2));
5691 if (SWIG_arg_fail(3)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 {
5696 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5697 result = (wxRect *) &_result_ref;
5698 }
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 wxRect *arg1 = (wxRect *) 0 ;
5713 int arg2 ;
5714 int arg3 ;
5715 PyObject * obj0 = 0 ;
5716 PyObject * obj1 = 0 ;
5717 PyObject * obj2 = 0 ;
5718 char *kwnames[] = {
5719 (char *) "self",(char *) "dx",(char *) "dy", NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5724 if (SWIG_arg_fail(1)) SWIG_fail;
5725 {
5726 arg2 = (int)(SWIG_As_int(obj1));
5727 if (SWIG_arg_fail(2)) SWIG_fail;
5728 }
5729 {
5730 arg3 = (int)(SWIG_As_int(obj2));
5731 if (SWIG_arg_fail(3)) SWIG_fail;
5732 }
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 (arg1)->Offset(arg2,arg3);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 Py_INCREF(Py_None); resultobj = Py_None;
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxRect *arg1 = (wxRect *) 0 ;
5750 wxPoint *arg2 = 0 ;
5751 wxPoint temp2 ;
5752 PyObject * obj0 = 0 ;
5753 PyObject * obj1 = 0 ;
5754 char *kwnames[] = {
5755 (char *) "self",(char *) "pt", NULL
5756 };
5757
5758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5760 if (SWIG_arg_fail(1)) SWIG_fail;
5761 {
5762 arg2 = &temp2;
5763 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5764 }
5765 {
5766 PyThreadState* __tstate = wxPyBeginAllowThreads();
5767 (arg1)->Offset((wxPoint const &)*arg2);
5768
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 Py_INCREF(Py_None); resultobj = Py_None;
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj;
5781 wxRect *arg1 = (wxRect *) 0 ;
5782 wxRect *arg2 = 0 ;
5783 wxRect result;
5784 wxRect temp2 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 char *kwnames[] = {
5788 (char *) "self",(char *) "rect", NULL
5789 };
5790
5791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5793 if (SWIG_arg_fail(1)) SWIG_fail;
5794 {
5795 arg2 = &temp2;
5796 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5797 }
5798 {
5799 PyThreadState* __tstate = wxPyBeginAllowThreads();
5800 result = (arg1)->Intersect((wxRect const &)*arg2);
5801
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 wxRect * resultptr;
5807 resultptr = new wxRect((wxRect &)(result));
5808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5809 }
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxRect *arg1 = (wxRect *) 0 ;
5819 wxRect *arg2 = 0 ;
5820 wxRect result;
5821 wxRect temp2 ;
5822 PyObject * obj0 = 0 ;
5823 PyObject * obj1 = 0 ;
5824 char *kwnames[] = {
5825 (char *) "self",(char *) "rect", NULL
5826 };
5827
5828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5830 if (SWIG_arg_fail(1)) SWIG_fail;
5831 {
5832 arg2 = &temp2;
5833 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (arg1)->Union((wxRect const &)*arg2);
5838
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 {
5843 wxRect * resultptr;
5844 resultptr = new wxRect((wxRect &)(result));
5845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5846 }
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect *result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 {
5912 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5913 result = (wxRect *) &_result_ref;
5914 }
5915
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj;
5928 wxRect *arg1 = (wxRect *) 0 ;
5929 wxRect *arg2 = 0 ;
5930 bool result;
5931 wxRect temp2 ;
5932 PyObject * obj0 = 0 ;
5933 PyObject * obj1 = 0 ;
5934 char *kwnames[] = {
5935 (char *) "self",(char *) "rect", NULL
5936 };
5937
5938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5940 if (SWIG_arg_fail(1)) SWIG_fail;
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5948
5949 wxPyEndAllowThreads(__tstate);
5950 if (PyErr_Occurred()) SWIG_fail;
5951 }
5952 {
5953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5954 }
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxRect *arg1 = (wxRect *) 0 ;
5964 wxRect *arg2 = 0 ;
5965 bool result;
5966 wxRect temp2 ;
5967 PyObject * obj0 = 0 ;
5968 PyObject * obj1 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "self",(char *) "rect", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 {
5977 arg2 = &temp2;
5978 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5979 }
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5983
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 {
5988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5989 }
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj;
5998 wxRect *arg1 = (wxRect *) 0 ;
5999 int arg2 ;
6000 int arg3 ;
6001 bool result;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 PyObject * obj2 = 0 ;
6005 char *kwnames[] = {
6006 (char *) "self",(char *) "x",(char *) "y", NULL
6007 };
6008
6009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6011 if (SWIG_arg_fail(1)) SWIG_fail;
6012 {
6013 arg2 = (int)(SWIG_As_int(obj1));
6014 if (SWIG_arg_fail(2)) SWIG_fail;
6015 }
6016 {
6017 arg3 = (int)(SWIG_As_int(obj2));
6018 if (SWIG_arg_fail(3)) SWIG_fail;
6019 }
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6029 }
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj;
6038 wxRect *arg1 = (wxRect *) 0 ;
6039 wxPoint *arg2 = 0 ;
6040 bool result;
6041 wxPoint temp2 ;
6042 PyObject * obj0 = 0 ;
6043 PyObject * obj1 = 0 ;
6044 char *kwnames[] = {
6045 (char *) "self",(char *) "pt", NULL
6046 };
6047
6048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6050 if (SWIG_arg_fail(1)) SWIG_fail;
6051 {
6052 arg2 = &temp2;
6053 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6054 }
6055 {
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6058
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 {
6063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6064 }
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj;
6073 wxRect *arg1 = (wxRect *) 0 ;
6074 wxRect *arg2 = 0 ;
6075 bool result;
6076 wxRect temp2 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "rect", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = &temp2;
6088 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6089 }
6090 {
6091 PyThreadState* __tstate = wxPyBeginAllowThreads();
6092 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6093
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 {
6098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6099 }
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6107 PyObject *resultobj;
6108 wxRect *arg1 = (wxRect *) 0 ;
6109 int arg2 ;
6110 PyObject * obj0 = 0 ;
6111 PyObject * obj1 = 0 ;
6112 char *kwnames[] = {
6113 (char *) "self",(char *) "x", NULL
6114 };
6115
6116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6118 if (SWIG_arg_fail(1)) SWIG_fail;
6119 {
6120 arg2 = (int)(SWIG_As_int(obj1));
6121 if (SWIG_arg_fail(2)) SWIG_fail;
6122 }
6123 if (arg1) (arg1)->x = arg2;
6124
6125 Py_INCREF(Py_None); resultobj = Py_None;
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxRect *arg1 = (wxRect *) 0 ;
6135 int result;
6136 PyObject * obj0 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 result = (int) ((arg1)->x);
6145
6146 {
6147 resultobj = SWIG_From_int((int)(result));
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 int arg2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char *kwnames[] = {
6162 (char *) "self",(char *) "y", NULL
6163 };
6164
6165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6167 if (SWIG_arg_fail(1)) SWIG_fail;
6168 {
6169 arg2 = (int)(SWIG_As_int(obj1));
6170 if (SWIG_arg_fail(2)) SWIG_fail;
6171 }
6172 if (arg1) (arg1)->y = arg2;
6173
6174 Py_INCREF(Py_None); resultobj = Py_None;
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxRect *arg1 = (wxRect *) 0 ;
6184 int result;
6185 PyObject * obj0 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 result = (int) ((arg1)->y);
6194
6195 {
6196 resultobj = SWIG_From_int((int)(result));
6197 }
6198 return resultobj;
6199 fail:
6200 return NULL;
6201 }
6202
6203
6204 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6205 PyObject *resultobj;
6206 wxRect *arg1 = (wxRect *) 0 ;
6207 int arg2 ;
6208 PyObject * obj0 = 0 ;
6209 PyObject * obj1 = 0 ;
6210 char *kwnames[] = {
6211 (char *) "self",(char *) "width", NULL
6212 };
6213
6214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 {
6218 arg2 = (int)(SWIG_As_int(obj1));
6219 if (SWIG_arg_fail(2)) SWIG_fail;
6220 }
6221 if (arg1) (arg1)->width = arg2;
6222
6223 Py_INCREF(Py_None); resultobj = Py_None;
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 int result;
6234 PyObject * obj0 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 result = (int) ((arg1)->width);
6243
6244 {
6245 resultobj = SWIG_From_int((int)(result));
6246 }
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 wxRect *arg1 = (wxRect *) 0 ;
6256 int arg2 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self",(char *) "height", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 arg2 = (int)(SWIG_As_int(obj1));
6268 if (SWIG_arg_fail(2)) SWIG_fail;
6269 }
6270 if (arg1) (arg1)->height = arg2;
6271
6272 Py_INCREF(Py_None); resultobj = Py_None;
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int result;
6283 PyObject * obj0 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 result = (int) ((arg1)->height);
6292
6293 {
6294 resultobj = SWIG_From_int((int)(result));
6295 }
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj;
6304 wxRect *arg1 = (wxRect *) 0 ;
6305 int arg2 = (int) 0 ;
6306 int arg3 = (int) 0 ;
6307 int arg4 = (int) 0 ;
6308 int arg5 = (int) 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 PyObject * obj2 = 0 ;
6312 PyObject * obj3 = 0 ;
6313 PyObject * obj4 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 if (obj1) {
6322 {
6323 arg2 = (int)(SWIG_As_int(obj1));
6324 if (SWIG_arg_fail(2)) SWIG_fail;
6325 }
6326 }
6327 if (obj2) {
6328 {
6329 arg3 = (int)(SWIG_As_int(obj2));
6330 if (SWIG_arg_fail(3)) SWIG_fail;
6331 }
6332 }
6333 if (obj3) {
6334 {
6335 arg4 = (int)(SWIG_As_int(obj3));
6336 if (SWIG_arg_fail(4)) SWIG_fail;
6337 }
6338 }
6339 if (obj4) {
6340 {
6341 arg5 = (int)(SWIG_As_int(obj4));
6342 if (SWIG_arg_fail(5)) SWIG_fail;
6343 }
6344 }
6345 {
6346 PyThreadState* __tstate = wxPyBeginAllowThreads();
6347 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6348
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
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_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj;
6361 wxRect *arg1 = (wxRect *) 0 ;
6362 PyObject *result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_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 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (PyObject *)wxRect_Get(arg1);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 resultobj = result;
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6386 PyObject *obj;
6387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6388 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6389 Py_INCREF(obj);
6390 return Py_BuildValue((char *)"");
6391 }
6392 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxRect *arg1 = (wxRect *) 0 ;
6395 wxRect *arg2 = (wxRect *) 0 ;
6396 PyObject *result;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "r1",(char *) "r2", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(2)) SWIG_fail;
6408 {
6409 if (!wxPyCheckForApp()) SWIG_fail;
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (PyObject *)wxIntersectRect(arg1,arg2);
6412
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = result;
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj;
6425 double arg1 = (double) 0.0 ;
6426 double arg2 = (double) 0.0 ;
6427 wxPoint2D *result;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "x",(char *) "y", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6435 if (obj0) {
6436 {
6437 arg1 = (double)(SWIG_As_double(obj0));
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 }
6440 }
6441 if (obj1) {
6442 {
6443 arg2 = (double)(SWIG_As_double(obj1));
6444 if (SWIG_arg_fail(2)) SWIG_fail;
6445 }
6446 }
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6450
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj;
6463 wxPoint2D *arg1 = 0 ;
6464 wxPoint2D *result;
6465 wxPoint2D temp1 ;
6466 PyObject * obj0 = 0 ;
6467 char *kwnames[] = {
6468 (char *) "pt", NULL
6469 };
6470
6471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6472 {
6473 arg1 = &temp1;
6474 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6475 }
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 wxPoint *arg1 = 0 ;
6493 wxPoint2D *result;
6494 wxPoint temp1 ;
6495 PyObject * obj0 = 0 ;
6496 char *kwnames[] = {
6497 (char *) "pt", NULL
6498 };
6499
6500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6501 {
6502 arg1 = &temp1;
6503 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6522 int *arg2 = (int *) 0 ;
6523 int *arg3 = (int *) 0 ;
6524 int temp2 ;
6525 int res2 = 0 ;
6526 int temp3 ;
6527 int res3 = 0 ;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6534 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6541
6542 wxPyEndAllowThreads(__tstate);
6543 if (PyErr_Occurred()) SWIG_fail;
6544 }
6545 Py_INCREF(Py_None); resultobj = Py_None;
6546 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6547 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6548 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6549 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj;
6558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6559 int *arg2 = (int *) 0 ;
6560 int *arg3 = (int *) 0 ;
6561 int temp2 ;
6562 int res2 = 0 ;
6563 int temp3 ;
6564 int res3 = 0 ;
6565 PyObject * obj0 = 0 ;
6566 char *kwnames[] = {
6567 (char *) "self", NULL
6568 };
6569
6570 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6571 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6574 if (SWIG_arg_fail(1)) SWIG_fail;
6575 {
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6578
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 Py_INCREF(Py_None); resultobj = Py_None;
6583 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6584 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6585 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6586 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 double result;
6597 PyObject * obj0 = 0 ;
6598 char *kwnames[] = {
6599 (char *) "self", NULL
6600 };
6601
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 {
6613 resultobj = SWIG_From_double((double)(result));
6614 }
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj;
6623 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6624 double result;
6625 PyObject * obj0 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self", NULL
6628 };
6629
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 {
6641 resultobj = SWIG_From_double((double)(result));
6642 }
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj;
6651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6652 double arg2 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 char *kwnames[] = {
6656 (char *) "self",(char *) "length", NULL
6657 };
6658
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(1)) SWIG_fail;
6662 {
6663 arg2 = (double)(SWIG_As_double(obj1));
6664 if (SWIG_arg_fail(2)) SWIG_fail;
6665 }
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 (arg1)->SetVectorLength(arg2);
6669
6670 wxPyEndAllowThreads(__tstate);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 Py_INCREF(Py_None); resultobj = Py_None;
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6681 PyObject *resultobj;
6682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6683 double arg2 ;
6684 PyObject * obj0 = 0 ;
6685 PyObject * obj1 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "self",(char *) "degrees", NULL
6688 };
6689
6690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6692 if (SWIG_arg_fail(1)) SWIG_fail;
6693 {
6694 arg2 = (double)(SWIG_As_double(obj1));
6695 if (SWIG_arg_fail(2)) SWIG_fail;
6696 }
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 (arg1)->SetVectorAngle(arg2);
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 Py_INCREF(Py_None); resultobj = Py_None;
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj;
6713 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6714 wxPoint2D *arg2 = 0 ;
6715 double result;
6716 wxPoint2D temp2 ;
6717 PyObject * obj0 = 0 ;
6718 PyObject * obj1 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self",(char *) "pt", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 arg2 = &temp2;
6728 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 {
6738 resultobj = SWIG_From_double((double)(result));
6739 }
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6747 PyObject *resultobj;
6748 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6749 wxPoint2D *arg2 = 0 ;
6750 double result;
6751 wxPoint2D temp2 ;
6752 PyObject * obj0 = 0 ;
6753 PyObject * obj1 = 0 ;
6754 char *kwnames[] = {
6755 (char *) "self",(char *) "pt", NULL
6756 };
6757
6758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6760 if (SWIG_arg_fail(1)) SWIG_fail;
6761 {
6762 arg2 = &temp2;
6763 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 {
6773 resultobj = SWIG_From_double((double)(result));
6774 }
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj;
6783 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6784 wxPoint2D *arg2 = 0 ;
6785 double result;
6786 wxPoint2D temp2 ;
6787 PyObject * obj0 = 0 ;
6788 PyObject * obj1 = 0 ;
6789 char *kwnames[] = {
6790 (char *) "self",(char *) "vec", NULL
6791 };
6792
6793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6795 if (SWIG_arg_fail(1)) SWIG_fail;
6796 {
6797 arg2 = &temp2;
6798 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6799 }
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6803
6804 wxPyEndAllowThreads(__tstate);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 {
6808 resultobj = SWIG_From_double((double)(result));
6809 }
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6819 wxPoint2D *arg2 = 0 ;
6820 double result;
6821 wxPoint2D temp2 ;
6822 PyObject * obj0 = 0 ;
6823 PyObject * obj1 = 0 ;
6824 char *kwnames[] = {
6825 (char *) "self",(char *) "vec", NULL
6826 };
6827
6828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6830 if (SWIG_arg_fail(1)) SWIG_fail;
6831 {
6832 arg2 = &temp2;
6833 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6834 }
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 {
6843 resultobj = SWIG_From_double((double)(result));
6844 }
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6852 PyObject *resultobj;
6853 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6854 wxPoint2D result;
6855 PyObject * obj0 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = (arg1)->operator -();
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 {
6871 wxPoint2D * resultptr;
6872 resultptr = new wxPoint2D((wxPoint2D &)(result));
6873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj;
6883 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6884 wxPoint2D *arg2 = 0 ;
6885 wxPoint2D *result;
6886 wxPoint2D temp2 ;
6887 PyObject * obj0 = 0 ;
6888 PyObject * obj1 = 0 ;
6889 char *kwnames[] = {
6890 (char *) "self",(char *) "pt", NULL
6891 };
6892
6893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6895 if (SWIG_arg_fail(1)) SWIG_fail;
6896 {
6897 arg2 = &temp2;
6898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6899 }
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 {
6903 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6904 result = (wxPoint2D *) &_result_ref;
6905 }
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6918 PyObject *resultobj;
6919 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6920 wxPoint2D *arg2 = 0 ;
6921 wxPoint2D *result;
6922 wxPoint2D temp2 ;
6923 PyObject * obj0 = 0 ;
6924 PyObject * obj1 = 0 ;
6925 char *kwnames[] = {
6926 (char *) "self",(char *) "pt", NULL
6927 };
6928
6929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6931 if (SWIG_arg_fail(1)) SWIG_fail;
6932 {
6933 arg2 = &temp2;
6934 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6935 }
6936 {
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 {
6939 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6940 result = (wxPoint2D *) &_result_ref;
6941 }
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6954 PyObject *resultobj;
6955 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6956 wxPoint2D *arg2 = 0 ;
6957 wxPoint2D *result;
6958 wxPoint2D temp2 ;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self",(char *) "pt", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 arg2 = &temp2;
6970 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6971 }
6972 {
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 {
6975 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6976 result = (wxPoint2D *) &_result_ref;
6977 }
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj;
6991 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6992 wxPoint2D *arg2 = 0 ;
6993 wxPoint2D *result;
6994 wxPoint2D temp2 ;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 char *kwnames[] = {
6998 (char *) "self",(char *) "pt", NULL
6999 };
7000
7001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7003 if (SWIG_arg_fail(1)) SWIG_fail;
7004 {
7005 arg2 = &temp2;
7006 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7007 }
7008 {
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 {
7011 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7012 result = (wxPoint2D *) &_result_ref;
7013 }
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7028 wxPoint2D *arg2 = 0 ;
7029 bool result;
7030 wxPoint2D temp2 ;
7031 PyObject * obj0 = 0 ;
7032 PyObject * obj1 = 0 ;
7033 char *kwnames[] = {
7034 (char *) "self",(char *) "pt", NULL
7035 };
7036
7037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7039 if (SWIG_arg_fail(1)) SWIG_fail;
7040 {
7041 arg2 = &temp2;
7042 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7043 }
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7047
7048 wxPyEndAllowThreads(__tstate);
7049 if (PyErr_Occurred()) SWIG_fail;
7050 }
7051 {
7052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7053 }
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj;
7062 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7063 wxPoint2D *arg2 = 0 ;
7064 bool result;
7065 wxPoint2D temp2 ;
7066 PyObject * obj0 = 0 ;
7067 PyObject * obj1 = 0 ;
7068 char *kwnames[] = {
7069 (char *) "self",(char *) "pt", NULL
7070 };
7071
7072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7074 if (SWIG_arg_fail(1)) SWIG_fail;
7075 {
7076 arg2 = &temp2;
7077 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7078 }
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7082
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 {
7087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7098 double arg2 ;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char *kwnames[] = {
7102 (char *) "self",(char *) "m_x", NULL
7103 };
7104
7105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7107 if (SWIG_arg_fail(1)) SWIG_fail;
7108 {
7109 arg2 = (double)(SWIG_As_double(obj1));
7110 if (SWIG_arg_fail(2)) SWIG_fail;
7111 }
7112 if (arg1) (arg1)->m_x = arg2;
7113
7114 Py_INCREF(Py_None); resultobj = Py_None;
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7124 double result;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 result = (double) ((arg1)->m_x);
7134
7135 {
7136 resultobj = SWIG_From_double((double)(result));
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7147 double arg2 ;
7148 PyObject * obj0 = 0 ;
7149 PyObject * obj1 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self",(char *) "m_y", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 {
7158 arg2 = (double)(SWIG_As_double(obj1));
7159 if (SWIG_arg_fail(2)) SWIG_fail;
7160 }
7161 if (arg1) (arg1)->m_y = arg2;
7162
7163 Py_INCREF(Py_None); resultobj = Py_None;
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj;
7172 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7173 double result;
7174 PyObject * obj0 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 result = (double) ((arg1)->m_y);
7183
7184 {
7185 resultobj = SWIG_From_double((double)(result));
7186 }
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7196 double arg2 = (double) 0 ;
7197 double arg3 = (double) 0 ;
7198 PyObject * obj0 = 0 ;
7199 PyObject * obj1 = 0 ;
7200 PyObject * obj2 = 0 ;
7201 char *kwnames[] = {
7202 (char *) "self",(char *) "x",(char *) "y", NULL
7203 };
7204
7205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7207 if (SWIG_arg_fail(1)) SWIG_fail;
7208 if (obj1) {
7209 {
7210 arg2 = (double)(SWIG_As_double(obj1));
7211 if (SWIG_arg_fail(2)) SWIG_fail;
7212 }
7213 }
7214 if (obj2) {
7215 {
7216 arg3 = (double)(SWIG_As_double(obj2));
7217 if (SWIG_arg_fail(3)) SWIG_fail;
7218 }
7219 }
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 wxPoint2D_Set(arg1,arg2,arg3);
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 Py_INCREF(Py_None); resultobj = Py_None;
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7237 PyObject *result;
7238 PyObject * obj0 = 0 ;
7239 char *kwnames[] = {
7240 (char *) "self", NULL
7241 };
7242
7243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7245 if (SWIG_arg_fail(1)) SWIG_fail;
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (PyObject *)wxPoint2D_Get(arg1);
7249
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = result;
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7261 PyObject *obj;
7262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7263 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7264 Py_INCREF(obj);
7265 return Py_BuildValue((char *)"");
7266 }
7267 static int _wrap_DefaultPosition_set(PyObject *) {
7268 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7269 return 1;
7270 }
7271
7272
7273 static PyObject *_wrap_DefaultPosition_get(void) {
7274 PyObject *pyobj;
7275
7276 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7277 return pyobj;
7278 }
7279
7280
7281 static int _wrap_DefaultSize_set(PyObject *) {
7282 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7283 return 1;
7284 }
7285
7286
7287 static PyObject *_wrap_DefaultSize_get(void) {
7288 PyObject *pyobj;
7289
7290 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7291 return pyobj;
7292 }
7293
7294
7295 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 PyObject *arg1 = (PyObject *) 0 ;
7298 wxPyInputStream *result;
7299 PyObject * obj0 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "p", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7305 arg1 = obj0;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj;
7322 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7323 PyObject * obj0 = 0 ;
7324 char *kwnames[] = {
7325 (char *) "self", NULL
7326 };
7327
7328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7330 if (SWIG_arg_fail(1)) SWIG_fail;
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 delete arg1;
7334
7335 wxPyEndAllowThreads(__tstate);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 Py_INCREF(Py_None); resultobj = Py_None;
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj;
7347 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7348 PyObject * obj0 = 0 ;
7349 char *kwnames[] = {
7350 (char *) "self", NULL
7351 };
7352
7353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7355 if (SWIG_arg_fail(1)) SWIG_fail;
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 (arg1)->close();
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 Py_INCREF(Py_None); resultobj = Py_None;
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj;
7372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "self", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7380 if (SWIG_arg_fail(1)) SWIG_fail;
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 (arg1)->flush();
7384
7385 wxPyEndAllowThreads(__tstate);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 Py_INCREF(Py_None); resultobj = Py_None;
7389 return resultobj;
7390 fail:
7391 return NULL;
7392 }
7393
7394
7395 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7396 PyObject *resultobj;
7397 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7398 bool result;
7399 PyObject * obj0 = 0 ;
7400 char *kwnames[] = {
7401 (char *) "self", NULL
7402 };
7403
7404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(1)) SWIG_fail;
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 result = (bool)(arg1)->eof();
7410
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 {
7415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7424 PyObject *resultobj;
7425 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7426 int arg2 = (int) -1 ;
7427 PyObject *result;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self",(char *) "size", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 if (obj1) {
7438 {
7439 arg2 = (int)(SWIG_As_int(obj1));
7440 if (SWIG_arg_fail(2)) SWIG_fail;
7441 }
7442 }
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 result = (PyObject *)(arg1)->read(arg2);
7446
7447 wxPyEndAllowThreads(__tstate);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 resultobj = result;
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7460 int arg2 = (int) -1 ;
7461 PyObject *result;
7462 PyObject * obj0 = 0 ;
7463 PyObject * obj1 = 0 ;
7464 char *kwnames[] = {
7465 (char *) "self",(char *) "size", NULL
7466 };
7467
7468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(1)) SWIG_fail;
7471 if (obj1) {
7472 {
7473 arg2 = (int)(SWIG_As_int(obj1));
7474 if (SWIG_arg_fail(2)) SWIG_fail;
7475 }
7476 }
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 result = (PyObject *)(arg1)->readline(arg2);
7480
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 resultobj = result;
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj;
7493 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7494 int arg2 = (int) -1 ;
7495 PyObject *result;
7496 PyObject * obj0 = 0 ;
7497 PyObject * obj1 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self",(char *) "sizehint", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 if (obj1) {
7506 {
7507 arg2 = (int)(SWIG_As_int(obj1));
7508 if (SWIG_arg_fail(2)) SWIG_fail;
7509 }
7510 }
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (PyObject *)(arg1)->readlines(arg2);
7514
7515 wxPyEndAllowThreads(__tstate);
7516 if (PyErr_Occurred()) SWIG_fail;
7517 }
7518 resultobj = result;
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj;
7527 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7528 int arg2 ;
7529 int arg3 = (int) 0 ;
7530 PyObject * obj0 = 0 ;
7531 PyObject * obj1 = 0 ;
7532 PyObject * obj2 = 0 ;
7533 char *kwnames[] = {
7534 (char *) "self",(char *) "offset",(char *) "whence", NULL
7535 };
7536
7537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7539 if (SWIG_arg_fail(1)) SWIG_fail;
7540 {
7541 arg2 = (int)(SWIG_As_int(obj1));
7542 if (SWIG_arg_fail(2)) SWIG_fail;
7543 }
7544 if (obj2) {
7545 {
7546 arg3 = (int)(SWIG_As_int(obj2));
7547 if (SWIG_arg_fail(3)) SWIG_fail;
7548 }
7549 }
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 (arg1)->seek(arg2,arg3);
7553
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 Py_INCREF(Py_None); resultobj = Py_None;
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj;
7566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7567 int result;
7568 PyObject * obj0 = 0 ;
7569 char *kwnames[] = {
7570 (char *) "self", NULL
7571 };
7572
7573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7575 if (SWIG_arg_fail(1)) SWIG_fail;
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (int)(arg1)->tell();
7579
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = SWIG_From_int((int)(result));
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7595 char result;
7596 PyObject * obj0 = 0 ;
7597 char *kwnames[] = {
7598 (char *) "self", NULL
7599 };
7600
7601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7603 if (SWIG_arg_fail(1)) SWIG_fail;
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 result = (char)(arg1)->Peek();
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 {
7612 resultobj = SWIG_From_char((char)(result));
7613 }
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7623 char result;
7624 PyObject * obj0 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 PyThreadState* __tstate = wxPyBeginAllowThreads();
7634 result = (char)(arg1)->GetC();
7635
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 {
7640 resultobj = SWIG_From_char((char)(result));
7641 }
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj;
7650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7651 size_t result;
7652 PyObject * obj0 = 0 ;
7653 char *kwnames[] = {
7654 (char *) "self", NULL
7655 };
7656
7657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(1)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (size_t)(arg1)->LastRead();
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 bool result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (bool)(arg1)->CanRead();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 bool result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (bool)(arg1)->Eof();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 char arg2 ;
7736 bool result;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self",(char *) "c", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 arg2 = (char)(SWIG_As_char(obj1));
7748 if (SWIG_arg_fail(2)) SWIG_fail;
7749 }
7750 {
7751 PyThreadState* __tstate = wxPyBeginAllowThreads();
7752 result = (bool)(arg1)->Ungetch(arg2);
7753
7754 wxPyEndAllowThreads(__tstate);
7755 if (PyErr_Occurred()) SWIG_fail;
7756 }
7757 {
7758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7759 }
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj;
7768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7769 long arg2 ;
7770 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7771 long result;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 PyObject * obj2 = 0 ;
7775 char *kwnames[] = {
7776 (char *) "self",(char *) "pos",(char *) "mode", NULL
7777 };
7778
7779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7781 if (SWIG_arg_fail(1)) SWIG_fail;
7782 {
7783 arg2 = (long)(SWIG_As_long(obj1));
7784 if (SWIG_arg_fail(2)) SWIG_fail;
7785 }
7786 if (obj2) {
7787 {
7788 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7789 if (SWIG_arg_fail(3)) SWIG_fail;
7790 }
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = SWIG_From_long((long)(result));
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7811 long result;
7812 PyObject * obj0 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 PyThreadState* __tstate = wxPyBeginAllowThreads();
7822 result = (long)(arg1)->TellI();
7823
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 {
7828 resultobj = SWIG_From_long((long)(result));
7829 }
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7837 PyObject *obj;
7838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7839 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7840 Py_INCREF(obj);
7841 return Py_BuildValue((char *)"");
7842 }
7843 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj;
7845 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7846 PyObject *arg2 = (PyObject *) 0 ;
7847 PyObject * obj0 = 0 ;
7848 PyObject * obj1 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "obj", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 arg2 = obj1;
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 wxOutputStream_write(arg1,arg2);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 Py_INCREF(Py_None); resultobj = Py_None;
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7872 PyObject *obj;
7873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7874 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7875 Py_INCREF(obj);
7876 return Py_BuildValue((char *)"");
7877 }
7878 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj;
7880 wxInputStream *arg1 = (wxInputStream *) 0 ;
7881 wxString *arg2 = 0 ;
7882 wxString *arg3 = 0 ;
7883 wxString *arg4 = 0 ;
7884 wxDateTime arg5 ;
7885 wxFSFile *result;
7886 wxPyInputStream *temp1 ;
7887 bool created1 ;
7888 bool temp2 = false ;
7889 bool temp3 = false ;
7890 bool temp4 = false ;
7891 PyObject * obj0 = 0 ;
7892 PyObject * obj1 = 0 ;
7893 PyObject * obj2 = 0 ;
7894 PyObject * obj3 = 0 ;
7895 PyObject * obj4 = 0 ;
7896 char *kwnames[] = {
7897 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7898 };
7899
7900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7901 {
7902 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7903 arg1 = temp1->m_wxis;
7904 created1 = false;
7905 } else {
7906 PyErr_Clear(); // clear the failure of the wxPyConvert above
7907 arg1 = wxPyCBInputStream_create(obj0, false);
7908 if (arg1 == NULL) {
7909 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7910 SWIG_fail;
7911 }
7912 created1 = true;
7913 }
7914 }
7915 {
7916 arg2 = wxString_in_helper(obj1);
7917 if (arg2 == NULL) SWIG_fail;
7918 temp2 = true;
7919 }
7920 {
7921 arg3 = wxString_in_helper(obj2);
7922 if (arg3 == NULL) SWIG_fail;
7923 temp3 = true;
7924 }
7925 {
7926 arg4 = wxString_in_helper(obj3);
7927 if (arg4 == NULL) SWIG_fail;
7928 temp4 = true;
7929 }
7930 {
7931 wxDateTime * argp;
7932 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7933 if (SWIG_arg_fail(5)) SWIG_fail;
7934 if (argp == NULL) {
7935 SWIG_null_ref("wxDateTime");
7936 }
7937 if (SWIG_arg_fail(5)) SWIG_fail;
7938 arg5 = *argp;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = wxPyMake_wxObject(result, 1);
7949 }
7950 {
7951 if (created1)
7952 delete arg1;
7953 }
7954 {
7955 if (temp2)
7956 delete arg2;
7957 }
7958 {
7959 if (temp3)
7960 delete arg3;
7961 }
7962 {
7963 if (temp4)
7964 delete arg4;
7965 }
7966 return resultobj;
7967 fail:
7968 {
7969 if (created1)
7970 delete arg1;
7971 }
7972 {
7973 if (temp2)
7974 delete arg2;
7975 }
7976 {
7977 if (temp3)
7978 delete arg3;
7979 }
7980 {
7981 if (temp4)
7982 delete arg4;
7983 }
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxFSFile *arg1 = (wxFSFile *) 0 ;
7991 PyObject * obj0 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "self", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
7997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
7998 if (SWIG_arg_fail(1)) SWIG_fail;
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 delete arg1;
8002
8003 wxPyEndAllowThreads(__tstate);
8004 if (PyErr_Occurred()) SWIG_fail;
8005 }
8006 Py_INCREF(Py_None); resultobj = Py_None;
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 wxFSFile *arg1 = (wxFSFile *) 0 ;
8016 wxInputStream *result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (wxInputStream *)(arg1)->GetStream();
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 {
8033 wxPyInputStream * _ptr = NULL;
8034
8035 if (result) {
8036 _ptr = new wxPyInputStream(result);
8037 }
8038 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8039 }
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8047 PyObject *resultobj;
8048 wxFSFile *arg1 = (wxFSFile *) 0 ;
8049 wxString *result;
8050 PyObject * obj0 = 0 ;
8051 char *kwnames[] = {
8052 (char *) "self", NULL
8053 };
8054
8055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8057 if (SWIG_arg_fail(1)) SWIG_fail;
8058 {
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 {
8061 wxString const &_result_ref = (arg1)->GetMimeType();
8062 result = (wxString *) &_result_ref;
8063 }
8064
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 #if wxUSE_UNICODE
8070 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8071 #else
8072 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8073 #endif
8074 }
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxFSFile *arg1 = (wxFSFile *) 0 ;
8084 wxString *result;
8085 PyObject * obj0 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 {
8096 wxString const &_result_ref = (arg1)->GetLocation();
8097 result = (wxString *) &_result_ref;
8098 }
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 {
8104 #if wxUSE_UNICODE
8105 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8106 #else
8107 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8108 #endif
8109 }
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxFSFile *arg1 = (wxFSFile *) 0 ;
8119 wxString *result;
8120 PyObject * obj0 = 0 ;
8121 char *kwnames[] = {
8122 (char *) "self", NULL
8123 };
8124
8125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8127 if (SWIG_arg_fail(1)) SWIG_fail;
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 {
8131 wxString const &_result_ref = (arg1)->GetAnchor();
8132 result = (wxString *) &_result_ref;
8133 }
8134
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 {
8139 #if wxUSE_UNICODE
8140 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8141 #else
8142 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8143 #endif
8144 }
8145 return resultobj;
8146 fail:
8147 return NULL;
8148 }
8149
8150
8151 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8152 PyObject *resultobj;
8153 wxFSFile *arg1 = (wxFSFile *) 0 ;
8154 wxDateTime result;
8155 PyObject * obj0 = 0 ;
8156 char *kwnames[] = {
8157 (char *) "self", NULL
8158 };
8159
8160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8162 if (SWIG_arg_fail(1)) SWIG_fail;
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (arg1)->GetModificationTime();
8166
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 {
8171 wxDateTime * resultptr;
8172 resultptr = new wxDateTime((wxDateTime &)(result));
8173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8174 }
8175 return resultobj;
8176 fail:
8177 return NULL;
8178 }
8179
8180
8181 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8182 PyObject *obj;
8183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8184 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8185 Py_INCREF(obj);
8186 return Py_BuildValue((char *)"");
8187 }
8188 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8189 PyObject *obj;
8190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8191 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8192 Py_INCREF(obj);
8193 return Py_BuildValue((char *)"");
8194 }
8195 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8196 PyObject *resultobj;
8197 wxPyFileSystemHandler *result;
8198 char *kwnames[] = {
8199 NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8206
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj;
8219 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8220 PyObject *arg2 = (PyObject *) 0 ;
8221 PyObject *arg3 = (PyObject *) 0 ;
8222 PyObject * obj0 = 0 ;
8223 PyObject * obj1 = 0 ;
8224 PyObject * obj2 = 0 ;
8225 char *kwnames[] = {
8226 (char *) "self",(char *) "self",(char *) "_class", NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8231 if (SWIG_arg_fail(1)) SWIG_fail;
8232 arg2 = obj1;
8233 arg3 = obj2;
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 (arg1)->_setCallbackInfo(arg2,arg3);
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 Py_INCREF(Py_None); resultobj = Py_None;
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8251 wxString *arg2 = 0 ;
8252 bool result;
8253 bool temp2 = false ;
8254 PyObject * obj0 = 0 ;
8255 PyObject * obj1 = 0 ;
8256 char *kwnames[] = {
8257 (char *) "self",(char *) "location", NULL
8258 };
8259
8260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8262 if (SWIG_arg_fail(1)) SWIG_fail;
8263 {
8264 arg2 = wxString_in_helper(obj1);
8265 if (arg2 == NULL) SWIG_fail;
8266 temp2 = true;
8267 }
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8271
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 {
8276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8277 }
8278 {
8279 if (temp2)
8280 delete arg2;
8281 }
8282 return resultobj;
8283 fail:
8284 {
8285 if (temp2)
8286 delete arg2;
8287 }
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj;
8294 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8295 wxFileSystem *arg2 = 0 ;
8296 wxString *arg3 = 0 ;
8297 wxFSFile *result;
8298 bool temp3 = false ;
8299 PyObject * obj0 = 0 ;
8300 PyObject * obj1 = 0 ;
8301 PyObject * obj2 = 0 ;
8302 char *kwnames[] = {
8303 (char *) "self",(char *) "fs",(char *) "location", NULL
8304 };
8305
8306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8308 if (SWIG_arg_fail(1)) SWIG_fail;
8309 {
8310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(2)) SWIG_fail;
8312 if (arg2 == NULL) {
8313 SWIG_null_ref("wxFileSystem");
8314 }
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 }
8317 {
8318 arg3 = wxString_in_helper(obj2);
8319 if (arg3 == NULL) SWIG_fail;
8320 temp3 = true;
8321 }
8322 {
8323 PyThreadState* __tstate = wxPyBeginAllowThreads();
8324 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8325
8326 wxPyEndAllowThreads(__tstate);
8327 if (PyErr_Occurred()) SWIG_fail;
8328 }
8329 {
8330 resultobj = wxPyMake_wxObject(result, 1);
8331 }
8332 {
8333 if (temp3)
8334 delete arg3;
8335 }
8336 return resultobj;
8337 fail:
8338 {
8339 if (temp3)
8340 delete arg3;
8341 }
8342 return NULL;
8343 }
8344
8345
8346 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj;
8348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8349 wxString *arg2 = 0 ;
8350 int arg3 = (int) 0 ;
8351 wxString result;
8352 bool temp2 = false ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 PyObject * obj2 = 0 ;
8356 char *kwnames[] = {
8357 (char *) "self",(char *) "spec",(char *) "flags", NULL
8358 };
8359
8360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8362 if (SWIG_arg_fail(1)) SWIG_fail;
8363 {
8364 arg2 = wxString_in_helper(obj1);
8365 if (arg2 == NULL) SWIG_fail;
8366 temp2 = true;
8367 }
8368 if (obj2) {
8369 {
8370 arg3 = (int)(SWIG_As_int(obj2));
8371 if (SWIG_arg_fail(3)) SWIG_fail;
8372 }
8373 }
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8377
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 {
8382 #if wxUSE_UNICODE
8383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8384 #else
8385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8386 #endif
8387 }
8388 {
8389 if (temp2)
8390 delete arg2;
8391 }
8392 return resultobj;
8393 fail:
8394 {
8395 if (temp2)
8396 delete arg2;
8397 }
8398 return NULL;
8399 }
8400
8401
8402 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj;
8404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8405 wxString result;
8406 PyObject * obj0 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 result = (arg1)->FindNext();
8417
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 {
8422 #if wxUSE_UNICODE
8423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8424 #else
8425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8426 #endif
8427 }
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj;
8436 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8437 wxString *arg2 = 0 ;
8438 wxString result;
8439 bool temp2 = false ;
8440 PyObject * obj0 = 0 ;
8441 PyObject * obj1 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self",(char *) "location", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 arg2 = wxString_in_helper(obj1);
8451 if (arg2 == NULL) SWIG_fail;
8452 temp2 = true;
8453 }
8454 {
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (arg1)->GetProtocol((wxString const &)*arg2);
8457
8458 wxPyEndAllowThreads(__tstate);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 {
8462 #if wxUSE_UNICODE
8463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8464 #else
8465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8466 #endif
8467 }
8468 {
8469 if (temp2)
8470 delete arg2;
8471 }
8472 return resultobj;
8473 fail:
8474 {
8475 if (temp2)
8476 delete arg2;
8477 }
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj;
8484 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8485 wxString *arg2 = 0 ;
8486 wxString result;
8487 bool temp2 = false ;
8488 PyObject * obj0 = 0 ;
8489 PyObject * obj1 = 0 ;
8490 char *kwnames[] = {
8491 (char *) "self",(char *) "location", NULL
8492 };
8493
8494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8496 if (SWIG_arg_fail(1)) SWIG_fail;
8497 {
8498 arg2 = wxString_in_helper(obj1);
8499 if (arg2 == NULL) SWIG_fail;
8500 temp2 = true;
8501 }
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 #if wxUSE_UNICODE
8511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8512 #else
8513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8514 #endif
8515 }
8516 {
8517 if (temp2)
8518 delete arg2;
8519 }
8520 return resultobj;
8521 fail:
8522 {
8523 if (temp2)
8524 delete arg2;
8525 }
8526 return NULL;
8527 }
8528
8529
8530 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8531 PyObject *resultobj;
8532 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8533 wxString *arg2 = 0 ;
8534 wxString result;
8535 bool temp2 = false ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 char *kwnames[] = {
8539 (char *) "self",(char *) "location", NULL
8540 };
8541
8542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8544 if (SWIG_arg_fail(1)) SWIG_fail;
8545 {
8546 arg2 = wxString_in_helper(obj1);
8547 if (arg2 == NULL) SWIG_fail;
8548 temp2 = true;
8549 }
8550 {
8551 PyThreadState* __tstate = wxPyBeginAllowThreads();
8552 result = (arg1)->GetAnchor((wxString const &)*arg2);
8553
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 #if wxUSE_UNICODE
8559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8560 #else
8561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8562 #endif
8563 }
8564 {
8565 if (temp2)
8566 delete arg2;
8567 }
8568 return resultobj;
8569 fail:
8570 {
8571 if (temp2)
8572 delete arg2;
8573 }
8574 return NULL;
8575 }
8576
8577
8578 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj;
8580 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8581 wxString *arg2 = 0 ;
8582 wxString result;
8583 bool temp2 = false ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 char *kwnames[] = {
8587 (char *) "self",(char *) "location", NULL
8588 };
8589
8590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 {
8594 arg2 = wxString_in_helper(obj1);
8595 if (arg2 == NULL) SWIG_fail;
8596 temp2 = true;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8601
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 {
8606 #if wxUSE_UNICODE
8607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8608 #else
8609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8610 #endif
8611 }
8612 {
8613 if (temp2)
8614 delete arg2;
8615 }
8616 return resultobj;
8617 fail:
8618 {
8619 if (temp2)
8620 delete arg2;
8621 }
8622 return NULL;
8623 }
8624
8625
8626 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj;
8628 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8629 wxString *arg2 = 0 ;
8630 wxString result;
8631 bool temp2 = false ;
8632 PyObject * obj0 = 0 ;
8633 PyObject * obj1 = 0 ;
8634 char *kwnames[] = {
8635 (char *) "self",(char *) "location", NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 {
8642 arg2 = wxString_in_helper(obj1);
8643 if (arg2 == NULL) SWIG_fail;
8644 temp2 = true;
8645 }
8646 {
8647 PyThreadState* __tstate = wxPyBeginAllowThreads();
8648 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8649
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 {
8654 #if wxUSE_UNICODE
8655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8656 #else
8657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8658 #endif
8659 }
8660 {
8661 if (temp2)
8662 delete arg2;
8663 }
8664 return resultobj;
8665 fail:
8666 {
8667 if (temp2)
8668 delete arg2;
8669 }
8670 return NULL;
8671 }
8672
8673
8674 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8675 PyObject *obj;
8676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8677 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8678 Py_INCREF(obj);
8679 return Py_BuildValue((char *)"");
8680 }
8681 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj;
8683 wxFileSystem *result;
8684 char *kwnames[] = {
8685 NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (wxFileSystem *)new wxFileSystem();
8692
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 {
8697 resultobj = wxPyMake_wxObject(result, 1);
8698 }
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj;
8707 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8708 PyObject * obj0 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "self", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 delete arg1;
8719
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 Py_INCREF(Py_None); resultobj = Py_None;
8724 return resultobj;
8725 fail:
8726 return NULL;
8727 }
8728
8729
8730 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8731 PyObject *resultobj;
8732 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8733 wxString *arg2 = 0 ;
8734 bool arg3 = (bool) false ;
8735 bool temp2 = false ;
8736 PyObject * obj0 = 0 ;
8737 PyObject * obj1 = 0 ;
8738 PyObject * obj2 = 0 ;
8739 char *kwnames[] = {
8740 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8741 };
8742
8743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8745 if (SWIG_arg_fail(1)) SWIG_fail;
8746 {
8747 arg2 = wxString_in_helper(obj1);
8748 if (arg2 == NULL) SWIG_fail;
8749 temp2 = true;
8750 }
8751 if (obj2) {
8752 {
8753 arg3 = (bool)(SWIG_As_bool(obj2));
8754 if (SWIG_arg_fail(3)) SWIG_fail;
8755 }
8756 }
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 Py_INCREF(Py_None); resultobj = Py_None;
8765 {
8766 if (temp2)
8767 delete arg2;
8768 }
8769 return resultobj;
8770 fail:
8771 {
8772 if (temp2)
8773 delete arg2;
8774 }
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj;
8781 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8782 wxString result;
8783 PyObject * obj0 = 0 ;
8784 char *kwnames[] = {
8785 (char *) "self", NULL
8786 };
8787
8788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8790 if (SWIG_arg_fail(1)) SWIG_fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 result = (arg1)->GetPath();
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 {
8799 #if wxUSE_UNICODE
8800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8801 #else
8802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8803 #endif
8804 }
8805 return resultobj;
8806 fail:
8807 return NULL;
8808 }
8809
8810
8811 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8812 PyObject *resultobj;
8813 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8814 wxString *arg2 = 0 ;
8815 wxFSFile *result;
8816 bool temp2 = false ;
8817 PyObject * obj0 = 0 ;
8818 PyObject * obj1 = 0 ;
8819 char *kwnames[] = {
8820 (char *) "self",(char *) "location", NULL
8821 };
8822
8823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8825 if (SWIG_arg_fail(1)) SWIG_fail;
8826 {
8827 arg2 = wxString_in_helper(obj1);
8828 if (arg2 == NULL) SWIG_fail;
8829 temp2 = true;
8830 }
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8834
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 {
8839 resultobj = wxPyMake_wxObject(result, 1);
8840 }
8841 {
8842 if (temp2)
8843 delete arg2;
8844 }
8845 return resultobj;
8846 fail:
8847 {
8848 if (temp2)
8849 delete arg2;
8850 }
8851 return NULL;
8852 }
8853
8854
8855 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8856 PyObject *resultobj;
8857 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8858 wxString *arg2 = 0 ;
8859 int arg3 = (int) 0 ;
8860 wxString result;
8861 bool temp2 = false ;
8862 PyObject * obj0 = 0 ;
8863 PyObject * obj1 = 0 ;
8864 PyObject * obj2 = 0 ;
8865 char *kwnames[] = {
8866 (char *) "self",(char *) "spec",(char *) "flags", NULL
8867 };
8868
8869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8871 if (SWIG_arg_fail(1)) SWIG_fail;
8872 {
8873 arg2 = wxString_in_helper(obj1);
8874 if (arg2 == NULL) SWIG_fail;
8875 temp2 = true;
8876 }
8877 if (obj2) {
8878 {
8879 arg3 = (int)(SWIG_As_int(obj2));
8880 if (SWIG_arg_fail(3)) SWIG_fail;
8881 }
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 {
8891 #if wxUSE_UNICODE
8892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8893 #else
8894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8895 #endif
8896 }
8897 {
8898 if (temp2)
8899 delete arg2;
8900 }
8901 return resultobj;
8902 fail:
8903 {
8904 if (temp2)
8905 delete arg2;
8906 }
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj;
8913 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8914 wxString result;
8915 PyObject * obj0 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "self", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 {
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 result = (arg1)->FindNext();
8926
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 {
8931 #if wxUSE_UNICODE
8932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8933 #else
8934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8935 #endif
8936 }
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj;
8945 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8946 PyObject * obj0 = 0 ;
8947 char *kwnames[] = {
8948 (char *) "handler", NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8953 if (SWIG_arg_fail(1)) SWIG_fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 wxFileSystem::AddHandler(arg1);
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 Py_INCREF(Py_None); resultobj = Py_None;
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 char *kwnames[] = {
8971 NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 wxFileSystem::CleanUpHandlers();
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 Py_INCREF(Py_None); resultobj = Py_None;
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 wxString *arg1 = 0 ;
8992 wxString result;
8993 bool temp1 = false ;
8994 PyObject * obj0 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "filename", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9000 {
9001 arg1 = wxString_in_helper(obj0);
9002 if (arg1 == NULL) SWIG_fail;
9003 temp1 = true;
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 {
9013 #if wxUSE_UNICODE
9014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9015 #else
9016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9017 #endif
9018 }
9019 {
9020 if (temp1)
9021 delete arg1;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp1)
9027 delete arg1;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxString *arg1 = 0 ;
9036 wxString result;
9037 bool temp1 = false ;
9038 PyObject * obj0 = 0 ;
9039 char *kwnames[] = {
9040 (char *) "url", NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9044 {
9045 arg1 = wxString_in_helper(obj0);
9046 if (arg1 == NULL) SWIG_fail;
9047 temp1 = true;
9048 }
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 result = FileSystem_URLToFileName((wxString const &)*arg1);
9052
9053 wxPyEndAllowThreads(__tstate);
9054 if (PyErr_Occurred()) SWIG_fail;
9055 }
9056 {
9057 #if wxUSE_UNICODE
9058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9059 #else
9060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9061 #endif
9062 }
9063 {
9064 if (temp1)
9065 delete arg1;
9066 }
9067 return resultobj;
9068 fail:
9069 {
9070 if (temp1)
9071 delete arg1;
9072 }
9073 return NULL;
9074 }
9075
9076
9077 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9078 PyObject *obj;
9079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9080 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9081 Py_INCREF(obj);
9082 return Py_BuildValue((char *)"");
9083 }
9084 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj;
9086 wxInternetFSHandler *result;
9087 char *kwnames[] = {
9088 NULL
9089 };
9090
9091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9095
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj;
9108 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9109 wxString *arg2 = 0 ;
9110 bool result;
9111 bool temp2 = false ;
9112 PyObject * obj0 = 0 ;
9113 PyObject * obj1 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "self",(char *) "location", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 {
9122 arg2 = wxString_in_helper(obj1);
9123 if (arg2 == NULL) SWIG_fail;
9124 temp2 = true;
9125 }
9126 {
9127 PyThreadState* __tstate = wxPyBeginAllowThreads();
9128 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9129
9130 wxPyEndAllowThreads(__tstate);
9131 if (PyErr_Occurred()) SWIG_fail;
9132 }
9133 {
9134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9135 }
9136 {
9137 if (temp2)
9138 delete arg2;
9139 }
9140 return resultobj;
9141 fail:
9142 {
9143 if (temp2)
9144 delete arg2;
9145 }
9146 return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj;
9152 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9153 wxFileSystem *arg2 = 0 ;
9154 wxString *arg3 = 0 ;
9155 wxFSFile *result;
9156 bool temp3 = false ;
9157 PyObject * obj0 = 0 ;
9158 PyObject * obj1 = 0 ;
9159 PyObject * obj2 = 0 ;
9160 char *kwnames[] = {
9161 (char *) "self",(char *) "fs",(char *) "location", NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9166 if (SWIG_arg_fail(1)) SWIG_fail;
9167 {
9168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9169 if (SWIG_arg_fail(2)) SWIG_fail;
9170 if (arg2 == NULL) {
9171 SWIG_null_ref("wxFileSystem");
9172 }
9173 if (SWIG_arg_fail(2)) SWIG_fail;
9174 }
9175 {
9176 arg3 = wxString_in_helper(obj2);
9177 if (arg3 == NULL) SWIG_fail;
9178 temp3 = true;
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9183
9184 wxPyEndAllowThreads(__tstate);
9185 if (PyErr_Occurred()) SWIG_fail;
9186 }
9187 {
9188 resultobj = wxPyMake_wxObject(result, 1);
9189 }
9190 {
9191 if (temp3)
9192 delete arg3;
9193 }
9194 return resultobj;
9195 fail:
9196 {
9197 if (temp3)
9198 delete arg3;
9199 }
9200 return NULL;
9201 }
9202
9203
9204 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9205 PyObject *obj;
9206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9207 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9208 Py_INCREF(obj);
9209 return Py_BuildValue((char *)"");
9210 }
9211 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 wxZipFSHandler *result;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (wxZipFSHandler *)new wxZipFSHandler();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9236 wxString *arg2 = 0 ;
9237 bool result;
9238 bool temp2 = false ;
9239 PyObject * obj0 = 0 ;
9240 PyObject * obj1 = 0 ;
9241 char *kwnames[] = {
9242 (char *) "self",(char *) "location", NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9247 if (SWIG_arg_fail(1)) SWIG_fail;
9248 {
9249 arg2 = wxString_in_helper(obj1);
9250 if (arg2 == NULL) SWIG_fail;
9251 temp2 = true;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9262 }
9263 {
9264 if (temp2)
9265 delete arg2;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp2)
9271 delete arg2;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9278 PyObject *resultobj;
9279 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9280 wxFileSystem *arg2 = 0 ;
9281 wxString *arg3 = 0 ;
9282 wxFSFile *result;
9283 bool temp3 = false ;
9284 PyObject * obj0 = 0 ;
9285 PyObject * obj1 = 0 ;
9286 PyObject * obj2 = 0 ;
9287 char *kwnames[] = {
9288 (char *) "self",(char *) "fs",(char *) "location", NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9293 if (SWIG_arg_fail(1)) SWIG_fail;
9294 {
9295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9296 if (SWIG_arg_fail(2)) SWIG_fail;
9297 if (arg2 == NULL) {
9298 SWIG_null_ref("wxFileSystem");
9299 }
9300 if (SWIG_arg_fail(2)) SWIG_fail;
9301 }
9302 {
9303 arg3 = wxString_in_helper(obj2);
9304 if (arg3 == NULL) SWIG_fail;
9305 temp3 = true;
9306 }
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 resultobj = wxPyMake_wxObject(result, 1);
9316 }
9317 {
9318 if (temp3)
9319 delete arg3;
9320 }
9321 return resultobj;
9322 fail:
9323 {
9324 if (temp3)
9325 delete arg3;
9326 }
9327 return NULL;
9328 }
9329
9330
9331 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj;
9333 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9334 wxString *arg2 = 0 ;
9335 int arg3 = (int) 0 ;
9336 wxString result;
9337 bool temp2 = false ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 PyObject * obj2 = 0 ;
9341 char *kwnames[] = {
9342 (char *) "self",(char *) "spec",(char *) "flags", NULL
9343 };
9344
9345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9347 if (SWIG_arg_fail(1)) SWIG_fail;
9348 {
9349 arg2 = wxString_in_helper(obj1);
9350 if (arg2 == NULL) SWIG_fail;
9351 temp2 = true;
9352 }
9353 if (obj2) {
9354 {
9355 arg3 = (int)(SWIG_As_int(obj2));
9356 if (SWIG_arg_fail(3)) SWIG_fail;
9357 }
9358 }
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9362
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 {
9367 #if wxUSE_UNICODE
9368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9369 #else
9370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9371 #endif
9372 }
9373 {
9374 if (temp2)
9375 delete arg2;
9376 }
9377 return resultobj;
9378 fail:
9379 {
9380 if (temp2)
9381 delete arg2;
9382 }
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9390 wxString result;
9391 PyObject * obj0 = 0 ;
9392 char *kwnames[] = {
9393 (char *) "self", NULL
9394 };
9395
9396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (arg1)->FindNext();
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 #if wxUSE_UNICODE
9408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9409 #else
9410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9411 #endif
9412 }
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9420 PyObject *obj;
9421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9422 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9423 Py_INCREF(obj);
9424 return Py_BuildValue((char *)"");
9425 }
9426 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9427 PyObject *resultobj;
9428 wxString *arg1 = 0 ;
9429 wxImage *arg2 = 0 ;
9430 long arg3 ;
9431 bool temp1 = false ;
9432 PyObject * obj0 = 0 ;
9433 PyObject * obj1 = 0 ;
9434 PyObject * obj2 = 0 ;
9435 char *kwnames[] = {
9436 (char *) "filename",(char *) "image",(char *) "type", NULL
9437 };
9438
9439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9440 {
9441 arg1 = wxString_in_helper(obj0);
9442 if (arg1 == NULL) SWIG_fail;
9443 temp1 = true;
9444 }
9445 {
9446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9447 if (SWIG_arg_fail(2)) SWIG_fail;
9448 if (arg2 == NULL) {
9449 SWIG_null_ref("wxImage");
9450 }
9451 if (SWIG_arg_fail(2)) SWIG_fail;
9452 }
9453 {
9454 arg3 = (long)(SWIG_As_long(obj2));
9455 if (SWIG_arg_fail(3)) SWIG_fail;
9456 }
9457 {
9458 PyThreadState* __tstate = wxPyBeginAllowThreads();
9459 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9460
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 Py_INCREF(Py_None); resultobj = Py_None;
9465 {
9466 if (temp1)
9467 delete arg1;
9468 }
9469 return resultobj;
9470 fail:
9471 {
9472 if (temp1)
9473 delete arg1;
9474 }
9475 return NULL;
9476 }
9477
9478
9479 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj;
9481 wxString *arg1 = 0 ;
9482 wxBitmap *arg2 = 0 ;
9483 long arg3 ;
9484 bool temp1 = false ;
9485 PyObject * obj0 = 0 ;
9486 PyObject * obj1 = 0 ;
9487 PyObject * obj2 = 0 ;
9488 char *kwnames[] = {
9489 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9490 };
9491
9492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9493 {
9494 arg1 = wxString_in_helper(obj0);
9495 if (arg1 == NULL) SWIG_fail;
9496 temp1 = true;
9497 }
9498 {
9499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9500 if (SWIG_arg_fail(2)) SWIG_fail;
9501 if (arg2 == NULL) {
9502 SWIG_null_ref("wxBitmap");
9503 }
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 }
9506 {
9507 arg3 = (long)(SWIG_As_long(obj2));
9508 if (SWIG_arg_fail(3)) SWIG_fail;
9509 }
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 Py_INCREF(Py_None); resultobj = Py_None;
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp1)
9526 delete arg1;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj;
9534 wxString *arg1 = 0 ;
9535 PyObject *arg2 = (PyObject *) 0 ;
9536 bool temp1 = false ;
9537 PyObject * obj0 = 0 ;
9538 PyObject * obj1 = 0 ;
9539 char *kwnames[] = {
9540 (char *) "filename",(char *) "data", NULL
9541 };
9542
9543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9544 {
9545 arg1 = wxString_in_helper(obj0);
9546 if (arg1 == NULL) SWIG_fail;
9547 temp1 = true;
9548 }
9549 arg2 = obj1;
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9553
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 Py_INCREF(Py_None); resultobj = Py_None;
9558 {
9559 if (temp1)
9560 delete arg1;
9561 }
9562 return resultobj;
9563 fail:
9564 {
9565 if (temp1)
9566 delete arg1;
9567 }
9568 return NULL;
9569 }
9570
9571
9572 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj;
9574 wxMemoryFSHandler *result;
9575 char *kwnames[] = {
9576 NULL
9577 };
9578
9579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9580 {
9581 PyThreadState* __tstate = wxPyBeginAllowThreads();
9582 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9583
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj;
9596 wxString *arg1 = 0 ;
9597 bool temp1 = false ;
9598 PyObject * obj0 = 0 ;
9599 char *kwnames[] = {
9600 (char *) "filename", NULL
9601 };
9602
9603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9604 {
9605 arg1 = wxString_in_helper(obj0);
9606 if (arg1 == NULL) SWIG_fail;
9607 temp1 = true;
9608 }
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 Py_INCREF(Py_None); resultobj = Py_None;
9617 {
9618 if (temp1)
9619 delete arg1;
9620 }
9621 return resultobj;
9622 fail:
9623 {
9624 if (temp1)
9625 delete arg1;
9626 }
9627 return NULL;
9628 }
9629
9630
9631 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj;
9633 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9634 wxString *arg2 = 0 ;
9635 bool result;
9636 bool temp2 = false ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char *kwnames[] = {
9640 (char *) "self",(char *) "location", NULL
9641 };
9642
9643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9645 if (SWIG_arg_fail(1)) SWIG_fail;
9646 {
9647 arg2 = wxString_in_helper(obj1);
9648 if (arg2 == NULL) SWIG_fail;
9649 temp2 = true;
9650 }
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9654
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 {
9659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9660 }
9661 {
9662 if (temp2)
9663 delete arg2;
9664 }
9665 return resultobj;
9666 fail:
9667 {
9668 if (temp2)
9669 delete arg2;
9670 }
9671 return NULL;
9672 }
9673
9674
9675 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj;
9677 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9678 wxFileSystem *arg2 = 0 ;
9679 wxString *arg3 = 0 ;
9680 wxFSFile *result;
9681 bool temp3 = false ;
9682 PyObject * obj0 = 0 ;
9683 PyObject * obj1 = 0 ;
9684 PyObject * obj2 = 0 ;
9685 char *kwnames[] = {
9686 (char *) "self",(char *) "fs",(char *) "location", NULL
9687 };
9688
9689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9691 if (SWIG_arg_fail(1)) SWIG_fail;
9692 {
9693 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(2)) SWIG_fail;
9695 if (arg2 == NULL) {
9696 SWIG_null_ref("wxFileSystem");
9697 }
9698 if (SWIG_arg_fail(2)) SWIG_fail;
9699 }
9700 {
9701 arg3 = wxString_in_helper(obj2);
9702 if (arg3 == NULL) SWIG_fail;
9703 temp3 = true;
9704 }
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9708
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 {
9713 resultobj = wxPyMake_wxObject(result, 1);
9714 }
9715 {
9716 if (temp3)
9717 delete arg3;
9718 }
9719 return resultobj;
9720 fail:
9721 {
9722 if (temp3)
9723 delete arg3;
9724 }
9725 return NULL;
9726 }
9727
9728
9729 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9730 PyObject *resultobj;
9731 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9732 wxString *arg2 = 0 ;
9733 int arg3 = (int) 0 ;
9734 wxString result;
9735 bool temp2 = false ;
9736 PyObject * obj0 = 0 ;
9737 PyObject * obj1 = 0 ;
9738 PyObject * obj2 = 0 ;
9739 char *kwnames[] = {
9740 (char *) "self",(char *) "spec",(char *) "flags", NULL
9741 };
9742
9743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9745 if (SWIG_arg_fail(1)) SWIG_fail;
9746 {
9747 arg2 = wxString_in_helper(obj1);
9748 if (arg2 == NULL) SWIG_fail;
9749 temp2 = true;
9750 }
9751 if (obj2) {
9752 {
9753 arg3 = (int)(SWIG_As_int(obj2));
9754 if (SWIG_arg_fail(3)) SWIG_fail;
9755 }
9756 }
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 #if wxUSE_UNICODE
9766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9767 #else
9768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9769 #endif
9770 }
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 return resultobj;
9776 fail:
9777 {
9778 if (temp2)
9779 delete arg2;
9780 }
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9788 wxString result;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = (arg1)->FindNext();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9818 PyObject *obj;
9819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9820 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9821 Py_INCREF(obj);
9822 return Py_BuildValue((char *)"");
9823 }
9824 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9827 wxString result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (arg1)->GetName();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 {
9844 #if wxUSE_UNICODE
9845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9846 #else
9847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9848 #endif
9849 }
9850 return resultobj;
9851 fail:
9852 return NULL;
9853 }
9854
9855
9856 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj;
9858 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9859 wxString result;
9860 PyObject * obj0 = 0 ;
9861 char *kwnames[] = {
9862 (char *) "self", NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9867 if (SWIG_arg_fail(1)) SWIG_fail;
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (arg1)->GetExtension();
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 {
9876 #if wxUSE_UNICODE
9877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9878 #else
9879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9880 #endif
9881 }
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9891 long result;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "self", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9899 if (SWIG_arg_fail(1)) SWIG_fail;
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = (long)(arg1)->GetType();
9903
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = SWIG_From_long((long)(result));
9909 }
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9919 wxString result;
9920 PyObject * obj0 = 0 ;
9921 char *kwnames[] = {
9922 (char *) "self", NULL
9923 };
9924
9925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9927 if (SWIG_arg_fail(1)) SWIG_fail;
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 result = (arg1)->GetMimeType();
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 {
9936 #if wxUSE_UNICODE
9937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9938 #else
9939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9940 #endif
9941 }
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj;
9950 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9951 wxString *arg2 = 0 ;
9952 bool result;
9953 bool temp2 = false ;
9954 PyObject * obj0 = 0 ;
9955 PyObject * obj1 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self",(char *) "name", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 arg2 = wxString_in_helper(obj1);
9965 if (arg2 == NULL) SWIG_fail;
9966 temp2 = true;
9967 }
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9977 }
9978 {
9979 if (temp2)
9980 delete arg2;
9981 }
9982 return resultobj;
9983 fail:
9984 {
9985 if (temp2)
9986 delete arg2;
9987 }
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9995 wxString *arg2 = 0 ;
9996 bool temp2 = false ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "self",(char *) "name", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10005 if (SWIG_arg_fail(1)) SWIG_fail;
10006 {
10007 arg2 = wxString_in_helper(obj1);
10008 if (arg2 == NULL) SWIG_fail;
10009 temp2 = true;
10010 }
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 (arg1)->SetName((wxString const &)*arg2);
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 Py_INCREF(Py_None); resultobj = Py_None;
10019 {
10020 if (temp2)
10021 delete arg2;
10022 }
10023 return resultobj;
10024 fail:
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return NULL;
10030 }
10031
10032
10033 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10034 PyObject *resultobj;
10035 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10036 wxString *arg2 = 0 ;
10037 bool temp2 = false ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 char *kwnames[] = {
10041 (char *) "self",(char *) "extension", NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10046 if (SWIG_arg_fail(1)) SWIG_fail;
10047 {
10048 arg2 = wxString_in_helper(obj1);
10049 if (arg2 == NULL) SWIG_fail;
10050 temp2 = true;
10051 }
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 (arg1)->SetExtension((wxString const &)*arg2);
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 Py_INCREF(Py_None); resultobj = Py_None;
10060 {
10061 if (temp2)
10062 delete arg2;
10063 }
10064 return resultobj;
10065 fail:
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return NULL;
10071 }
10072
10073
10074 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10075 PyObject *resultobj;
10076 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10077 long arg2 ;
10078 PyObject * obj0 = 0 ;
10079 PyObject * obj1 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "self",(char *) "type", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10086 if (SWIG_arg_fail(1)) SWIG_fail;
10087 {
10088 arg2 = (long)(SWIG_As_long(obj1));
10089 if (SWIG_arg_fail(2)) SWIG_fail;
10090 }
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 (arg1)->SetType(arg2);
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 Py_INCREF(Py_None); resultobj = Py_None;
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 wxString *arg2 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char *kwnames[] = {
10113 (char *) "self",(char *) "mimetype", NULL
10114 };
10115
10116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10118 if (SWIG_arg_fail(1)) SWIG_fail;
10119 {
10120 arg2 = wxString_in_helper(obj1);
10121 if (arg2 == NULL) SWIG_fail;
10122 temp2 = true;
10123 }
10124 {
10125 PyThreadState* __tstate = wxPyBeginAllowThreads();
10126 (arg1)->SetMimeType((wxString const &)*arg2);
10127
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 Py_INCREF(Py_None); resultobj = Py_None;
10132 {
10133 if (temp2)
10134 delete arg2;
10135 }
10136 return resultobj;
10137 fail:
10138 {
10139 if (temp2)
10140 delete arg2;
10141 }
10142 return NULL;
10143 }
10144
10145
10146 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10147 PyObject *obj;
10148 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10149 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10150 Py_INCREF(obj);
10151 return Py_BuildValue((char *)"");
10152 }
10153 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxImageHistogram *result;
10156 char *kwnames[] = {
10157 NULL
10158 };
10159
10160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10161 {
10162 PyThreadState* __tstate = wxPyBeginAllowThreads();
10163 result = (wxImageHistogram *)new wxImageHistogram();
10164
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10169 return resultobj;
10170 fail:
10171 return NULL;
10172 }
10173
10174
10175 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj;
10177 unsigned char arg1 ;
10178 unsigned char arg2 ;
10179 unsigned char arg3 ;
10180 unsigned long result;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 PyObject * obj2 = 0 ;
10184 char *kwnames[] = {
10185 (char *) "r",(char *) "g",(char *) "b", NULL
10186 };
10187
10188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10189 {
10190 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 }
10193 {
10194 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10195 if (SWIG_arg_fail(2)) SWIG_fail;
10196 }
10197 {
10198 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10199 if (SWIG_arg_fail(3)) SWIG_fail;
10200 }
10201 {
10202 PyThreadState* __tstate = wxPyBeginAllowThreads();
10203 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10204
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 {
10209 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10218 PyObject *resultobj;
10219 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10220 unsigned char *arg2 = (unsigned char *) 0 ;
10221 unsigned char *arg3 = (unsigned char *) 0 ;
10222 unsigned char *arg4 = (unsigned char *) 0 ;
10223 unsigned char arg5 = (unsigned char) 1 ;
10224 unsigned char arg6 = (unsigned char) 0 ;
10225 unsigned char arg7 = (unsigned char) 0 ;
10226 bool result;
10227 unsigned char temp2 ;
10228 int res2 = 0 ;
10229 unsigned char temp3 ;
10230 int res3 = 0 ;
10231 unsigned char temp4 ;
10232 int res4 = 0 ;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 PyObject * obj2 = 0 ;
10236 PyObject * obj3 = 0 ;
10237 char *kwnames[] = {
10238 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10239 };
10240
10241 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10242 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10243 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10246 if (SWIG_arg_fail(1)) SWIG_fail;
10247 if (obj1) {
10248 {
10249 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10250 if (SWIG_arg_fail(5)) SWIG_fail;
10251 }
10252 }
10253 if (obj2) {
10254 {
10255 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10256 if (SWIG_arg_fail(6)) SWIG_fail;
10257 }
10258 }
10259 if (obj3) {
10260 {
10261 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10262 if (SWIG_arg_fail(7)) SWIG_fail;
10263 }
10264 }
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10268
10269 wxPyEndAllowThreads(__tstate);
10270 if (PyErr_Occurred()) SWIG_fail;
10271 }
10272 {
10273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10274 }
10275 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10276 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10277 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10278 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10279 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10288 PyObject *obj;
10289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10290 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10291 Py_INCREF(obj);
10292 return Py_BuildValue((char *)"");
10293 }
10294 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj;
10296 wxString *arg1 = 0 ;
10297 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10298 int arg3 = (int) -1 ;
10299 wxImage *result;
10300 bool temp1 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 char *kwnames[] = {
10305 (char *) "name",(char *) "type",(char *) "index", NULL
10306 };
10307
10308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10309 {
10310 arg1 = wxString_in_helper(obj0);
10311 if (arg1 == NULL) SWIG_fail;
10312 temp1 = true;
10313 }
10314 if (obj1) {
10315 {
10316 arg2 = (long)(SWIG_As_long(obj1));
10317 if (SWIG_arg_fail(2)) SWIG_fail;
10318 }
10319 }
10320 if (obj2) {
10321 {
10322 arg3 = (int)(SWIG_As_int(obj2));
10323 if (SWIG_arg_fail(3)) SWIG_fail;
10324 }
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10329
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10334 {
10335 if (temp1)
10336 delete arg1;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp1)
10342 delete arg1;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj;
10350 wxImage *arg1 = (wxImage *) 0 ;
10351 PyObject * obj0 = 0 ;
10352 char *kwnames[] = {
10353 (char *) "self", NULL
10354 };
10355
10356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(1)) SWIG_fail;
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 delete arg1;
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxString *arg1 = 0 ;
10376 wxString *arg2 = 0 ;
10377 int arg3 = (int) -1 ;
10378 wxImage *result;
10379 bool temp1 = false ;
10380 bool temp2 = false ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 PyObject * obj2 = 0 ;
10384 char *kwnames[] = {
10385 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10386 };
10387
10388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10389 {
10390 arg1 = wxString_in_helper(obj0);
10391 if (arg1 == NULL) SWIG_fail;
10392 temp1 = true;
10393 }
10394 {
10395 arg2 = wxString_in_helper(obj1);
10396 if (arg2 == NULL) SWIG_fail;
10397 temp2 = true;
10398 }
10399 if (obj2) {
10400 {
10401 arg3 = (int)(SWIG_As_int(obj2));
10402 if (SWIG_arg_fail(3)) SWIG_fail;
10403 }
10404 }
10405 {
10406 PyThreadState* __tstate = wxPyBeginAllowThreads();
10407 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10408
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10413 {
10414 if (temp1)
10415 delete arg1;
10416 }
10417 {
10418 if (temp2)
10419 delete arg2;
10420 }
10421 return resultobj;
10422 fail:
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxInputStream *arg1 = 0 ;
10438 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10439 int arg3 = (int) -1 ;
10440 wxImage *result;
10441 wxPyInputStream *temp1 ;
10442 bool created1 ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445 PyObject * obj2 = 0 ;
10446 char *kwnames[] = {
10447 (char *) "stream",(char *) "type",(char *) "index", NULL
10448 };
10449
10450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10451 {
10452 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10453 arg1 = temp1->m_wxis;
10454 created1 = false;
10455 } else {
10456 PyErr_Clear(); // clear the failure of the wxPyConvert above
10457 arg1 = wxPyCBInputStream_create(obj0, false);
10458 if (arg1 == NULL) {
10459 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10460 SWIG_fail;
10461 }
10462 created1 = true;
10463 }
10464 }
10465 if (obj1) {
10466 {
10467 arg2 = (long)(SWIG_As_long(obj1));
10468 if (SWIG_arg_fail(2)) SWIG_fail;
10469 }
10470 }
10471 if (obj2) {
10472 {
10473 arg3 = (int)(SWIG_As_int(obj2));
10474 if (SWIG_arg_fail(3)) SWIG_fail;
10475 }
10476 }
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10480
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10485 {
10486 if (created1)
10487 delete arg1;
10488 }
10489 return resultobj;
10490 fail:
10491 {
10492 if (created1)
10493 delete arg1;
10494 }
10495 return NULL;
10496 }
10497
10498
10499 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10500 PyObject *resultobj;
10501 wxInputStream *arg1 = 0 ;
10502 wxString *arg2 = 0 ;
10503 int arg3 = (int) -1 ;
10504 wxImage *result;
10505 wxPyInputStream *temp1 ;
10506 bool created1 ;
10507 bool temp2 = false ;
10508 PyObject * obj0 = 0 ;
10509 PyObject * obj1 = 0 ;
10510 PyObject * obj2 = 0 ;
10511 char *kwnames[] = {
10512 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10513 };
10514
10515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10516 {
10517 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10518 arg1 = temp1->m_wxis;
10519 created1 = false;
10520 } else {
10521 PyErr_Clear(); // clear the failure of the wxPyConvert above
10522 arg1 = wxPyCBInputStream_create(obj0, false);
10523 if (arg1 == NULL) {
10524 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10525 SWIG_fail;
10526 }
10527 created1 = true;
10528 }
10529 }
10530 {
10531 arg2 = wxString_in_helper(obj1);
10532 if (arg2 == NULL) SWIG_fail;
10533 temp2 = true;
10534 }
10535 if (obj2) {
10536 {
10537 arg3 = (int)(SWIG_As_int(obj2));
10538 if (SWIG_arg_fail(3)) SWIG_fail;
10539 }
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10544
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10549 {
10550 if (created1)
10551 delete arg1;
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (created1)
10561 delete arg1;
10562 }
10563 {
10564 if (temp2)
10565 delete arg2;
10566 }
10567 return NULL;
10568 }
10569
10570
10571 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj;
10573 int arg1 = (int) 0 ;
10574 int arg2 = (int) 0 ;
10575 bool arg3 = (bool) true ;
10576 wxImage *result;
10577 PyObject * obj0 = 0 ;
10578 PyObject * obj1 = 0 ;
10579 PyObject * obj2 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "width",(char *) "height",(char *) "clear", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10585 if (obj0) {
10586 {
10587 arg1 = (int)(SWIG_As_int(obj0));
10588 if (SWIG_arg_fail(1)) SWIG_fail;
10589 }
10590 }
10591 if (obj1) {
10592 {
10593 arg2 = (int)(SWIG_As_int(obj1));
10594 if (SWIG_arg_fail(2)) SWIG_fail;
10595 }
10596 }
10597 if (obj2) {
10598 {
10599 arg3 = (bool)(SWIG_As_bool(obj2));
10600 if (SWIG_arg_fail(3)) SWIG_fail;
10601 }
10602 }
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10606
10607 wxPyEndAllowThreads(__tstate);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10618 PyObject *resultobj;
10619 wxBitmap *arg1 = 0 ;
10620 wxImage *result;
10621 PyObject * obj0 = 0 ;
10622 char *kwnames[] = {
10623 (char *) "bitmap", NULL
10624 };
10625
10626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10627 {
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 if (arg1 == NULL) {
10631 SWIG_null_ref("wxBitmap");
10632 }
10633 if (SWIG_arg_fail(1)) SWIG_fail;
10634 }
10635 {
10636 if (!wxPyCheckForApp()) SWIG_fail;
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10639
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj;
10652 int arg1 ;
10653 int arg2 ;
10654 unsigned char *arg3 = (unsigned char *) 0 ;
10655 wxImage *result;
10656 PyObject * obj0 = 0 ;
10657 PyObject * obj1 = 0 ;
10658 PyObject * obj2 = 0 ;
10659 char *kwnames[] = {
10660 (char *) "width",(char *) "height",(char *) "data", NULL
10661 };
10662
10663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10664 {
10665 arg1 = (int)(SWIG_As_int(obj0));
10666 if (SWIG_arg_fail(1)) SWIG_fail;
10667 }
10668 {
10669 arg2 = (int)(SWIG_As_int(obj1));
10670 if (SWIG_arg_fail(2)) SWIG_fail;
10671 }
10672 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10673 if (SWIG_arg_fail(3)) SWIG_fail;
10674 {
10675 PyThreadState* __tstate = wxPyBeginAllowThreads();
10676 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10677
10678 wxPyEndAllowThreads(__tstate);
10679 if (PyErr_Occurred()) SWIG_fail;
10680 }
10681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10682 return resultobj;
10683 fail:
10684 return NULL;
10685 }
10686
10687
10688 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10689 PyObject *resultobj;
10690 int arg1 ;
10691 int arg2 ;
10692 unsigned char *arg3 = (unsigned char *) 0 ;
10693 unsigned char *arg4 = (unsigned char *) 0 ;
10694 wxImage *result;
10695 PyObject * obj0 = 0 ;
10696 PyObject * obj1 = 0 ;
10697 PyObject * obj2 = 0 ;
10698 PyObject * obj3 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10704 {
10705 arg1 = (int)(SWIG_As_int(obj0));
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 }
10708 {
10709 arg2 = (int)(SWIG_As_int(obj1));
10710 if (SWIG_arg_fail(2)) SWIG_fail;
10711 }
10712 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10713 if (SWIG_arg_fail(3)) SWIG_fail;
10714 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10715 if (SWIG_arg_fail(4)) SWIG_fail;
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10719
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj;
10732 wxImage *arg1 = (wxImage *) 0 ;
10733 int arg2 ;
10734 int arg3 ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 PyObject * obj2 = 0 ;
10738 char *kwnames[] = {
10739 (char *) "self",(char *) "width",(char *) "height", NULL
10740 };
10741
10742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10744 if (SWIG_arg_fail(1)) SWIG_fail;
10745 {
10746 arg2 = (int)(SWIG_As_int(obj1));
10747 if (SWIG_arg_fail(2)) SWIG_fail;
10748 }
10749 {
10750 arg3 = (int)(SWIG_As_int(obj2));
10751 if (SWIG_arg_fail(3)) SWIG_fail;
10752 }
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 (arg1)->Create(arg2,arg3);
10756
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 Py_INCREF(Py_None); resultobj = Py_None;
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj;
10769 wxImage *arg1 = (wxImage *) 0 ;
10770 PyObject * obj0 = 0 ;
10771 char *kwnames[] = {
10772 (char *) "self", NULL
10773 };
10774
10775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10777 if (SWIG_arg_fail(1)) SWIG_fail;
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 (arg1)->Destroy();
10781
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 Py_INCREF(Py_None); resultobj = Py_None;
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj;
10794 wxImage *arg1 = (wxImage *) 0 ;
10795 int arg2 ;
10796 int arg3 ;
10797 SwigValueWrapper<wxImage > result;
10798 PyObject * obj0 = 0 ;
10799 PyObject * obj1 = 0 ;
10800 PyObject * obj2 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "self",(char *) "width",(char *) "height", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 {
10809 arg2 = (int)(SWIG_As_int(obj1));
10810 if (SWIG_arg_fail(2)) SWIG_fail;
10811 }
10812 {
10813 arg3 = (int)(SWIG_As_int(obj2));
10814 if (SWIG_arg_fail(3)) SWIG_fail;
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 result = (arg1)->Scale(arg2,arg3);
10819
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 {
10824 wxImage * resultptr;
10825 resultptr = new wxImage((wxImage &)(result));
10826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10827 }
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 wxImage *arg1 = (wxImage *) 0 ;
10837 int arg2 ;
10838 int arg3 ;
10839 SwigValueWrapper<wxImage > result;
10840 PyObject * obj0 = 0 ;
10841 PyObject * obj1 = 0 ;
10842 PyObject * obj2 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = (int)(SWIG_As_int(obj1));
10852 if (SWIG_arg_fail(2)) SWIG_fail;
10853 }
10854 {
10855 arg3 = (int)(SWIG_As_int(obj2));
10856 if (SWIG_arg_fail(3)) SWIG_fail;
10857 }
10858 {
10859 PyThreadState* __tstate = wxPyBeginAllowThreads();
10860 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10861
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 {
10866 wxImage * resultptr;
10867 resultptr = new wxImage((wxImage &)(result));
10868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10869 }
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj;
10878 wxImage *arg1 = (wxImage *) 0 ;
10879 int arg2 ;
10880 int arg3 ;
10881 wxImage *result;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 PyObject * obj2 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self",(char *) "width",(char *) "height", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 arg3 = (int)(SWIG_As_int(obj2));
10898 if (SWIG_arg_fail(3)) SWIG_fail;
10899 }
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 {
10903 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10904 result = (wxImage *) &_result_ref;
10905 }
10906
10907 wxPyEndAllowThreads(__tstate);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10918 PyObject *resultobj;
10919 wxImage *arg1 = (wxImage *) 0 ;
10920 int arg2 ;
10921 int arg3 ;
10922 unsigned char arg4 ;
10923 unsigned char arg5 ;
10924 unsigned char arg6 ;
10925 PyObject * obj0 = 0 ;
10926 PyObject * obj1 = 0 ;
10927 PyObject * obj2 = 0 ;
10928 PyObject * obj3 = 0 ;
10929 PyObject * obj4 = 0 ;
10930 PyObject * obj5 = 0 ;
10931 char *kwnames[] = {
10932 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10933 };
10934
10935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10937 if (SWIG_arg_fail(1)) SWIG_fail;
10938 {
10939 arg2 = (int)(SWIG_As_int(obj1));
10940 if (SWIG_arg_fail(2)) SWIG_fail;
10941 }
10942 {
10943 arg3 = (int)(SWIG_As_int(obj2));
10944 if (SWIG_arg_fail(3)) SWIG_fail;
10945 }
10946 {
10947 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10948 if (SWIG_arg_fail(4)) SWIG_fail;
10949 }
10950 {
10951 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10952 if (SWIG_arg_fail(5)) SWIG_fail;
10953 }
10954 {
10955 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10956 if (SWIG_arg_fail(6)) SWIG_fail;
10957 }
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj;
10974 wxImage *arg1 = (wxImage *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 unsigned char result;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "x",(char *) "y", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj;
11014 wxImage *arg1 = (wxImage *) 0 ;
11015 int arg2 ;
11016 int arg3 ;
11017 unsigned char result;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 PyObject * obj2 = 0 ;
11021 char *kwnames[] = {
11022 (char *) "self",(char *) "x",(char *) "y", NULL
11023 };
11024
11025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11027 if (SWIG_arg_fail(1)) SWIG_fail;
11028 {
11029 arg2 = (int)(SWIG_As_int(obj1));
11030 if (SWIG_arg_fail(2)) SWIG_fail;
11031 }
11032 {
11033 arg3 = (int)(SWIG_As_int(obj2));
11034 if (SWIG_arg_fail(3)) SWIG_fail;
11035 }
11036 {
11037 PyThreadState* __tstate = wxPyBeginAllowThreads();
11038 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11039
11040 wxPyEndAllowThreads(__tstate);
11041 if (PyErr_Occurred()) SWIG_fail;
11042 }
11043 {
11044 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11045 }
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11053 PyObject *resultobj;
11054 wxImage *arg1 = (wxImage *) 0 ;
11055 int arg2 ;
11056 int arg3 ;
11057 unsigned char result;
11058 PyObject * obj0 = 0 ;
11059 PyObject * obj1 = 0 ;
11060 PyObject * obj2 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "self",(char *) "x",(char *) "y", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11067 if (SWIG_arg_fail(1)) SWIG_fail;
11068 {
11069 arg2 = (int)(SWIG_As_int(obj1));
11070 if (SWIG_arg_fail(2)) SWIG_fail;
11071 }
11072 {
11073 arg3 = (int)(SWIG_As_int(obj2));
11074 if (SWIG_arg_fail(3)) SWIG_fail;
11075 }
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11079
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11085 }
11086 return resultobj;
11087 fail:
11088 return NULL;
11089 }
11090
11091
11092 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj;
11094 wxImage *arg1 = (wxImage *) 0 ;
11095 int arg2 ;
11096 int arg3 ;
11097 unsigned char arg4 ;
11098 PyObject * obj0 = 0 ;
11099 PyObject * obj1 = 0 ;
11100 PyObject * obj2 = 0 ;
11101 PyObject * obj3 = 0 ;
11102 char *kwnames[] = {
11103 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11104 };
11105
11106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11108 if (SWIG_arg_fail(1)) SWIG_fail;
11109 {
11110 arg2 = (int)(SWIG_As_int(obj1));
11111 if (SWIG_arg_fail(2)) SWIG_fail;
11112 }
11113 {
11114 arg3 = (int)(SWIG_As_int(obj2));
11115 if (SWIG_arg_fail(3)) SWIG_fail;
11116 }
11117 {
11118 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11119 if (SWIG_arg_fail(4)) SWIG_fail;
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 (arg1)->SetAlpha(arg2,arg3,arg4);
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 Py_INCREF(Py_None); resultobj = Py_None;
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj;
11137 wxImage *arg1 = (wxImage *) 0 ;
11138 int arg2 ;
11139 int arg3 ;
11140 unsigned char result;
11141 PyObject * obj0 = 0 ;
11142 PyObject * obj1 = 0 ;
11143 PyObject * obj2 = 0 ;
11144 char *kwnames[] = {
11145 (char *) "self",(char *) "x",(char *) "y", NULL
11146 };
11147
11148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11150 if (SWIG_arg_fail(1)) SWIG_fail;
11151 {
11152 arg2 = (int)(SWIG_As_int(obj1));
11153 if (SWIG_arg_fail(2)) SWIG_fail;
11154 }
11155 {
11156 arg3 = (int)(SWIG_As_int(obj2));
11157 if (SWIG_arg_fail(3)) SWIG_fail;
11158 }
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11168 }
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11176 PyObject *resultobj;
11177 wxImage *arg1 = (wxImage *) 0 ;
11178 bool result;
11179 PyObject * obj0 = 0 ;
11180 char *kwnames[] = {
11181 (char *) "self", NULL
11182 };
11183
11184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11186 if (SWIG_arg_fail(1)) SWIG_fail;
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (bool)(arg1)->HasAlpha();
11190
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 {
11195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11196 }
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11204 PyObject *resultobj;
11205 wxImage *arg1 = (wxImage *) 0 ;
11206 byte *arg2 = (byte *) 0 ;
11207 byte *arg3 = (byte *) 0 ;
11208 byte *arg4 = (byte *) 0 ;
11209 byte arg5 = (byte) 0 ;
11210 byte arg6 = (byte) 0 ;
11211 byte arg7 = (byte) 0 ;
11212 bool result;
11213 byte temp2 ;
11214 int res2 = 0 ;
11215 byte temp3 ;
11216 int res3 = 0 ;
11217 byte temp4 ;
11218 int res4 = 0 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 PyObject * obj2 = 0 ;
11222 PyObject * obj3 = 0 ;
11223 char *kwnames[] = {
11224 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11225 };
11226
11227 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11228 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11229 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 if (obj1) {
11234 {
11235 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11236 if (SWIG_arg_fail(5)) SWIG_fail;
11237 }
11238 }
11239 if (obj2) {
11240 {
11241 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11242 if (SWIG_arg_fail(6)) SWIG_fail;
11243 }
11244 }
11245 if (obj3) {
11246 {
11247 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11248 if (SWIG_arg_fail(7)) SWIG_fail;
11249 }
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 {
11259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11260 }
11261 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11262 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11263 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11264 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11265 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11267 return resultobj;
11268 fail:
11269 return NULL;
11270 }
11271
11272
11273 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11274 PyObject *resultobj;
11275 wxImage *arg1 = (wxImage *) 0 ;
11276 byte arg2 = (byte) 128 ;
11277 bool result;
11278 PyObject * obj0 = 0 ;
11279 PyObject * obj1 = 0 ;
11280 char *kwnames[] = {
11281 (char *) "self",(char *) "threshold", NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 if (obj1) {
11288 {
11289 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11290 if (SWIG_arg_fail(2)) SWIG_fail;
11291 }
11292 }
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 unsigned char arg2 ;
11313 unsigned char arg3 ;
11314 unsigned char arg4 ;
11315 bool result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 PyObject * obj2 = 0 ;
11319 PyObject * obj3 = 0 ;
11320 char *kwnames[] = {
11321 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11322 };
11323
11324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11326 if (SWIG_arg_fail(1)) SWIG_fail;
11327 {
11328 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11329 if (SWIG_arg_fail(2)) SWIG_fail;
11330 }
11331 {
11332 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11333 if (SWIG_arg_fail(3)) SWIG_fail;
11334 }
11335 {
11336 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11337 if (SWIG_arg_fail(4)) SWIG_fail;
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11342
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 {
11347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11348 }
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj;
11357 wxImage *arg1 = (wxImage *) 0 ;
11358 wxImage *arg2 = 0 ;
11359 byte arg3 ;
11360 byte arg4 ;
11361 byte arg5 ;
11362 bool result;
11363 PyObject * obj0 = 0 ;
11364 PyObject * obj1 = 0 ;
11365 PyObject * obj2 = 0 ;
11366 PyObject * obj3 = 0 ;
11367 PyObject * obj4 = 0 ;
11368 char *kwnames[] = {
11369 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11370 };
11371
11372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11374 if (SWIG_arg_fail(1)) SWIG_fail;
11375 {
11376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(2)) SWIG_fail;
11378 if (arg2 == NULL) {
11379 SWIG_null_ref("wxImage");
11380 }
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 {
11384 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11385 if (SWIG_arg_fail(3)) SWIG_fail;
11386 }
11387 {
11388 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11389 if (SWIG_arg_fail(4)) SWIG_fail;
11390 }
11391 {
11392 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11393 if (SWIG_arg_fail(5)) SWIG_fail;
11394 }
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11398
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 {
11403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11404 }
11405 return resultobj;
11406 fail:
11407 return NULL;
11408 }
11409
11410
11411 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11412 PyObject *resultobj;
11413 wxString *arg1 = 0 ;
11414 bool result;
11415 bool temp1 = false ;
11416 PyObject * obj0 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "name", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11430
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11436 }
11437 {
11438 if (temp1)
11439 delete arg1;
11440 }
11441 return resultobj;
11442 fail:
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return NULL;
11448 }
11449
11450
11451 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj;
11453 wxString *arg1 = 0 ;
11454 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11455 int result;
11456 bool temp1 = false ;
11457 PyObject * obj0 = 0 ;
11458 PyObject * obj1 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "name",(char *) "type", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11464 {
11465 arg1 = wxString_in_helper(obj0);
11466 if (arg1 == NULL) SWIG_fail;
11467 temp1 = true;
11468 }
11469 if (obj1) {
11470 {
11471 arg2 = (long)(SWIG_As_long(obj1));
11472 if (SWIG_arg_fail(2)) SWIG_fail;
11473 }
11474 }
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11478
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = SWIG_From_int((int)(result));
11484 }
11485 {
11486 if (temp1)
11487 delete arg1;
11488 }
11489 return resultobj;
11490 fail:
11491 {
11492 if (temp1)
11493 delete arg1;
11494 }
11495 return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj;
11501 wxImage *arg1 = (wxImage *) 0 ;
11502 wxString *arg2 = 0 ;
11503 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11504 int arg4 = (int) -1 ;
11505 bool result;
11506 bool temp2 = false ;
11507 PyObject * obj0 = 0 ;
11508 PyObject * obj1 = 0 ;
11509 PyObject * obj2 = 0 ;
11510 PyObject * obj3 = 0 ;
11511 char *kwnames[] = {
11512 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11513 };
11514
11515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11517 if (SWIG_arg_fail(1)) SWIG_fail;
11518 {
11519 arg2 = wxString_in_helper(obj1);
11520 if (arg2 == NULL) SWIG_fail;
11521 temp2 = true;
11522 }
11523 if (obj2) {
11524 {
11525 arg3 = (long)(SWIG_As_long(obj2));
11526 if (SWIG_arg_fail(3)) SWIG_fail;
11527 }
11528 }
11529 if (obj3) {
11530 {
11531 arg4 = (int)(SWIG_As_int(obj3));
11532 if (SWIG_arg_fail(4)) SWIG_fail;
11533 }
11534 }
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11538
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11544 }
11545 {
11546 if (temp2)
11547 delete arg2;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp2)
11553 delete arg2;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj;
11561 wxImage *arg1 = (wxImage *) 0 ;
11562 wxString *arg2 = 0 ;
11563 wxString *arg3 = 0 ;
11564 int arg4 = (int) -1 ;
11565 bool result;
11566 bool temp2 = false ;
11567 bool temp3 = false ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 PyObject * obj3 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 arg2 = wxString_in_helper(obj1);
11581 if (arg2 == NULL) SWIG_fail;
11582 temp2 = true;
11583 }
11584 {
11585 arg3 = wxString_in_helper(obj2);
11586 if (arg3 == NULL) SWIG_fail;
11587 temp3 = true;
11588 }
11589 if (obj3) {
11590 {
11591 arg4 = (int)(SWIG_As_int(obj3));
11592 if (SWIG_arg_fail(4)) SWIG_fail;
11593 }
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11598
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11604 }
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 {
11610 if (temp3)
11611 delete arg3;
11612 }
11613 return resultobj;
11614 fail:
11615 {
11616 if (temp2)
11617 delete arg2;
11618 }
11619 {
11620 if (temp3)
11621 delete arg3;
11622 }
11623 return NULL;
11624 }
11625
11626
11627 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11628 PyObject *resultobj;
11629 wxImage *arg1 = (wxImage *) 0 ;
11630 wxString *arg2 = 0 ;
11631 int arg3 ;
11632 bool result;
11633 bool temp2 = false ;
11634 PyObject * obj0 = 0 ;
11635 PyObject * obj1 = 0 ;
11636 PyObject * obj2 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self",(char *) "name",(char *) "type", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 arg2 = wxString_in_helper(obj1);
11646 if (arg2 == NULL) SWIG_fail;
11647 temp2 = true;
11648 }
11649 {
11650 arg3 = (int)(SWIG_As_int(obj2));
11651 if (SWIG_arg_fail(3)) SWIG_fail;
11652 }
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11662 }
11663 {
11664 if (temp2)
11665 delete arg2;
11666 }
11667 return resultobj;
11668 fail:
11669 {
11670 if (temp2)
11671 delete arg2;
11672 }
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxImage *arg1 = (wxImage *) 0 ;
11680 wxString *arg2 = 0 ;
11681 wxString *arg3 = 0 ;
11682 bool result;
11683 bool temp2 = false ;
11684 bool temp3 = false ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 char *kwnames[] = {
11689 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11690 };
11691
11692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11694 if (SWIG_arg_fail(1)) SWIG_fail;
11695 {
11696 arg2 = wxString_in_helper(obj1);
11697 if (arg2 == NULL) SWIG_fail;
11698 temp2 = true;
11699 }
11700 {
11701 arg3 = wxString_in_helper(obj2);
11702 if (arg3 == NULL) SWIG_fail;
11703 temp3 = true;
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11708
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 {
11713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11714 }
11715 {
11716 if (temp2)
11717 delete arg2;
11718 }
11719 {
11720 if (temp3)
11721 delete arg3;
11722 }
11723 return resultobj;
11724 fail:
11725 {
11726 if (temp2)
11727 delete arg2;
11728 }
11729 {
11730 if (temp3)
11731 delete arg3;
11732 }
11733 return NULL;
11734 }
11735
11736
11737 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11738 PyObject *resultobj;
11739 wxInputStream *arg1 = 0 ;
11740 bool result;
11741 wxPyInputStream *temp1 ;
11742 bool created1 ;
11743 PyObject * obj0 = 0 ;
11744 char *kwnames[] = {
11745 (char *) "stream", NULL
11746 };
11747
11748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11749 {
11750 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11751 arg1 = temp1->m_wxis;
11752 created1 = false;
11753 } else {
11754 PyErr_Clear(); // clear the failure of the wxPyConvert above
11755 arg1 = wxPyCBInputStream_create(obj0, false);
11756 if (arg1 == NULL) {
11757 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11758 SWIG_fail;
11759 }
11760 created1 = true;
11761 }
11762 }
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (bool)wxImage::CanRead(*arg1);
11766
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 {
11771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11772 }
11773 {
11774 if (created1)
11775 delete arg1;
11776 }
11777 return resultobj;
11778 fail:
11779 {
11780 if (created1)
11781 delete arg1;
11782 }
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxImage *arg1 = (wxImage *) 0 ;
11790 wxInputStream *arg2 = 0 ;
11791 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11792 int arg4 = (int) -1 ;
11793 bool result;
11794 wxPyInputStream *temp2 ;
11795 bool created2 ;
11796 PyObject * obj0 = 0 ;
11797 PyObject * obj1 = 0 ;
11798 PyObject * obj2 = 0 ;
11799 PyObject * obj3 = 0 ;
11800 char *kwnames[] = {
11801 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11802 };
11803
11804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11806 if (SWIG_arg_fail(1)) SWIG_fail;
11807 {
11808 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11809 arg2 = temp2->m_wxis;
11810 created2 = false;
11811 } else {
11812 PyErr_Clear(); // clear the failure of the wxPyConvert above
11813 arg2 = wxPyCBInputStream_create(obj1, false);
11814 if (arg2 == NULL) {
11815 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11816 SWIG_fail;
11817 }
11818 created2 = true;
11819 }
11820 }
11821 if (obj2) {
11822 {
11823 arg3 = (long)(SWIG_As_long(obj2));
11824 if (SWIG_arg_fail(3)) SWIG_fail;
11825 }
11826 }
11827 if (obj3) {
11828 {
11829 arg4 = (int)(SWIG_As_int(obj3));
11830 if (SWIG_arg_fail(4)) SWIG_fail;
11831 }
11832 }
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11836
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 {
11844 if (created2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (created2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj;
11859 wxImage *arg1 = (wxImage *) 0 ;
11860 wxInputStream *arg2 = 0 ;
11861 wxString *arg3 = 0 ;
11862 int arg4 = (int) -1 ;
11863 bool result;
11864 wxPyInputStream *temp2 ;
11865 bool created2 ;
11866 bool temp3 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 PyObject * obj2 = 0 ;
11870 PyObject * obj3 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11880 arg2 = temp2->m_wxis;
11881 created2 = false;
11882 } else {
11883 PyErr_Clear(); // clear the failure of the wxPyConvert above
11884 arg2 = wxPyCBInputStream_create(obj1, false);
11885 if (arg2 == NULL) {
11886 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11887 SWIG_fail;
11888 }
11889 created2 = true;
11890 }
11891 }
11892 {
11893 arg3 = wxString_in_helper(obj2);
11894 if (arg3 == NULL) SWIG_fail;
11895 temp3 = true;
11896 }
11897 if (obj3) {
11898 {
11899 arg4 = (int)(SWIG_As_int(obj3));
11900 if (SWIG_arg_fail(4)) SWIG_fail;
11901 }
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11906
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11912 }
11913 {
11914 if (created2)
11915 delete arg2;
11916 }
11917 {
11918 if (temp3)
11919 delete arg3;
11920 }
11921 return resultobj;
11922 fail:
11923 {
11924 if (created2)
11925 delete arg2;
11926 }
11927 {
11928 if (temp3)
11929 delete arg3;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxImage *arg1 = (wxImage *) 0 ;
11938 bool result;
11939 PyObject * obj0 = 0 ;
11940 char *kwnames[] = {
11941 (char *) "self", NULL
11942 };
11943
11944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11946 if (SWIG_arg_fail(1)) SWIG_fail;
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = (bool)(arg1)->Ok();
11950
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 {
11955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11956 }
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj;
11965 wxImage *arg1 = (wxImage *) 0 ;
11966 int result;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (int)(arg1)->GetWidth();
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = SWIG_From_int((int)(result));
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj;
11993 wxImage *arg1 = (wxImage *) 0 ;
11994 int result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (int)(arg1)->GetHeight();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = SWIG_From_int((int)(result));
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12020 PyObject *resultobj;
12021 wxImage *arg1 = (wxImage *) 0 ;
12022 wxSize result;
12023 PyObject * obj0 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = wxImage_GetSize(arg1);
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 wxSize * resultptr;
12040 resultptr = new wxSize((wxSize &)(result));
12041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxImage *arg1 = (wxImage *) 0 ;
12052 wxRect *arg2 = 0 ;
12053 SwigValueWrapper<wxImage > result;
12054 wxRect temp2 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char *kwnames[] = {
12058 (char *) "self",(char *) "rect", NULL
12059 };
12060
12061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12063 if (SWIG_arg_fail(1)) SWIG_fail;
12064 {
12065 arg2 = &temp2;
12066 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12071
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 {
12076 wxImage * resultptr;
12077 resultptr = new wxImage((wxImage &)(result));
12078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxImage *arg1 = (wxImage *) 0 ;
12089 SwigValueWrapper<wxImage > result;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = (arg1)->Copy();
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 wxImage * resultptr;
12107 resultptr = new wxImage((wxImage &)(result));
12108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj;
12118 wxImage *arg1 = (wxImage *) 0 ;
12119 wxImage *arg2 = 0 ;
12120 int arg3 ;
12121 int arg4 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 PyObject * obj2 = 0 ;
12125 PyObject * obj3 = 0 ;
12126 char *kwnames[] = {
12127 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12128 };
12129
12130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12132 if (SWIG_arg_fail(1)) SWIG_fail;
12133 {
12134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(2)) SWIG_fail;
12136 if (arg2 == NULL) {
12137 SWIG_null_ref("wxImage");
12138 }
12139 if (SWIG_arg_fail(2)) SWIG_fail;
12140 }
12141 {
12142 arg3 = (int)(SWIG_As_int(obj2));
12143 if (SWIG_arg_fail(3)) SWIG_fail;
12144 }
12145 {
12146 arg4 = (int)(SWIG_As_int(obj3));
12147 if (SWIG_arg_fail(4)) SWIG_fail;
12148 }
12149 {
12150 PyThreadState* __tstate = wxPyBeginAllowThreads();
12151 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12152
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 Py_INCREF(Py_None); resultobj = Py_None;
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxImage *arg1 = (wxImage *) 0 ;
12166 PyObject *result;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (PyObject *)wxImage_GetData(arg1);
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 resultobj = result;
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxImage *arg1 = (wxImage *) 0 ;
12192 PyObject *arg2 = (PyObject *) 0 ;
12193 PyObject * obj0 = 0 ;
12194 PyObject * obj1 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self",(char *) "data", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 arg2 = obj1;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 wxImage_SetData(arg1,arg2);
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 Py_INCREF(Py_None); resultobj = Py_None;
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxImage *arg1 = (wxImage *) 0 ;
12220 PyObject *result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = result;
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxImage *arg1 = (wxImage *) 0 ;
12246 PyObject *arg2 = (PyObject *) 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self",(char *) "data", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 arg2 = obj1;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 wxImage_SetDataBuffer(arg1,arg2);
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxImage *arg1 = (wxImage *) 0 ;
12274 PyObject *result;
12275 PyObject * obj0 = 0 ;
12276 char *kwnames[] = {
12277 (char *) "self", NULL
12278 };
12279
12280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12282 if (SWIG_arg_fail(1)) SWIG_fail;
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (PyObject *)wxImage_GetAlphaData(arg1);
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj;
12299 wxImage *arg1 = (wxImage *) 0 ;
12300 PyObject *arg2 = (PyObject *) 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self",(char *) "data", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 arg2 = obj1;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 wxImage_SetAlphaData(arg1,arg2);
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 Py_INCREF(Py_None); resultobj = Py_None;
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj;
12327 wxImage *arg1 = (wxImage *) 0 ;
12328 PyObject *result;
12329 PyObject * obj0 = 0 ;
12330 char *kwnames[] = {
12331 (char *) "self", NULL
12332 };
12333
12334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12336 if (SWIG_arg_fail(1)) SWIG_fail;
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12340
12341 wxPyEndAllowThreads(__tstate);
12342 if (PyErr_Occurred()) SWIG_fail;
12343 }
12344 resultobj = result;
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxImage *arg1 = (wxImage *) 0 ;
12354 PyObject *arg2 = (PyObject *) 0 ;
12355 PyObject * obj0 = 0 ;
12356 PyObject * obj1 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "data", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 arg2 = obj1;
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 wxImage_SetAlphaBuffer(arg1,arg2);
12368
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 Py_INCREF(Py_None); resultobj = Py_None;
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxImage *arg1 = (wxImage *) 0 ;
12382 unsigned char arg2 ;
12383 unsigned char arg3 ;
12384 unsigned char arg4 ;
12385 PyObject * obj0 = 0 ;
12386 PyObject * obj1 = 0 ;
12387 PyObject * obj2 = 0 ;
12388 PyObject * obj3 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12398 if (SWIG_arg_fail(2)) SWIG_fail;
12399 }
12400 {
12401 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12402 if (SWIG_arg_fail(3)) SWIG_fail;
12403 }
12404 {
12405 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12406 if (SWIG_arg_fail(4)) SWIG_fail;
12407 }
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 (arg1)->SetMaskColour(arg2,arg3,arg4);
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 Py_INCREF(Py_None); resultobj = Py_None;
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj;
12424 wxImage *arg1 = (wxImage *) 0 ;
12425 unsigned char result;
12426 PyObject * obj0 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 result = (unsigned char)(arg1)->GetMaskRed();
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 {
12442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12443 }
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj;
12452 wxImage *arg1 = (wxImage *) 0 ;
12453 unsigned char result;
12454 PyObject * obj0 = 0 ;
12455 char *kwnames[] = {
12456 (char *) "self", NULL
12457 };
12458
12459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(1)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (unsigned char)(arg1)->GetMaskGreen();
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj;
12480 wxImage *arg1 = (wxImage *) 0 ;
12481 unsigned char result;
12482 PyObject * obj0 = 0 ;
12483 char *kwnames[] = {
12484 (char *) "self", NULL
12485 };
12486
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12489 if (SWIG_arg_fail(1)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = (unsigned char)(arg1)->GetMaskBlue();
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 {
12498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12499 }
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12507 PyObject *resultobj;
12508 wxImage *arg1 = (wxImage *) 0 ;
12509 bool arg2 = (bool) true ;
12510 PyObject * obj0 = 0 ;
12511 PyObject * obj1 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self",(char *) "mask", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 if (obj1) {
12520 {
12521 arg2 = (bool)(SWIG_As_bool(obj1));
12522 if (SWIG_arg_fail(2)) SWIG_fail;
12523 }
12524 }
12525 {
12526 PyThreadState* __tstate = wxPyBeginAllowThreads();
12527 (arg1)->SetMask(arg2);
12528
12529 wxPyEndAllowThreads(__tstate);
12530 if (PyErr_Occurred()) SWIG_fail;
12531 }
12532 Py_INCREF(Py_None); resultobj = Py_None;
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12540 PyObject *resultobj;
12541 wxImage *arg1 = (wxImage *) 0 ;
12542 bool result;
12543 PyObject * obj0 = 0 ;
12544 char *kwnames[] = {
12545 (char *) "self", NULL
12546 };
12547
12548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12550 if (SWIG_arg_fail(1)) SWIG_fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (bool)(arg1)->HasMask();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 {
12559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12560 }
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj;
12569 wxImage *arg1 = (wxImage *) 0 ;
12570 double arg2 ;
12571 wxPoint *arg3 = 0 ;
12572 bool arg4 = (bool) true ;
12573 wxPoint *arg5 = (wxPoint *) NULL ;
12574 SwigValueWrapper<wxImage > result;
12575 wxPoint temp3 ;
12576 PyObject * obj0 = 0 ;
12577 PyObject * obj1 = 0 ;
12578 PyObject * obj2 = 0 ;
12579 PyObject * obj3 = 0 ;
12580 PyObject * obj4 = 0 ;
12581 char *kwnames[] = {
12582 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12583 };
12584
12585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12587 if (SWIG_arg_fail(1)) SWIG_fail;
12588 {
12589 arg2 = (double)(SWIG_As_double(obj1));
12590 if (SWIG_arg_fail(2)) SWIG_fail;
12591 }
12592 {
12593 arg3 = &temp3;
12594 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12595 }
12596 if (obj3) {
12597 {
12598 arg4 = (bool)(SWIG_As_bool(obj3));
12599 if (SWIG_arg_fail(4)) SWIG_fail;
12600 }
12601 }
12602 if (obj4) {
12603 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(5)) SWIG_fail;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 {
12614 wxImage * resultptr;
12615 resultptr = new wxImage((wxImage &)(result));
12616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12617 }
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj;
12626 wxImage *arg1 = (wxImage *) 0 ;
12627 bool arg2 = (bool) true ;
12628 SwigValueWrapper<wxImage > result;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 char *kwnames[] = {
12632 (char *) "self",(char *) "clockwise", NULL
12633 };
12634
12635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12637 if (SWIG_arg_fail(1)) SWIG_fail;
12638 if (obj1) {
12639 {
12640 arg2 = (bool)(SWIG_As_bool(obj1));
12641 if (SWIG_arg_fail(2)) SWIG_fail;
12642 }
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = (arg1)->Rotate90(arg2);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 wxImage * resultptr;
12653 resultptr = new wxImage((wxImage &)(result));
12654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxImage *arg1 = (wxImage *) 0 ;
12665 bool arg2 = (bool) true ;
12666 SwigValueWrapper<wxImage > result;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "horizontally", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 if (obj1) {
12677 {
12678 arg2 = (bool)(SWIG_As_bool(obj1));
12679 if (SWIG_arg_fail(2)) SWIG_fail;
12680 }
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (arg1)->Mirror(arg2);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 {
12690 wxImage * resultptr;
12691 resultptr = new wxImage((wxImage &)(result));
12692 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj;
12702 wxImage *arg1 = (wxImage *) 0 ;
12703 unsigned char arg2 ;
12704 unsigned char arg3 ;
12705 unsigned char arg4 ;
12706 unsigned char arg5 ;
12707 unsigned char arg6 ;
12708 unsigned char arg7 ;
12709 PyObject * obj0 = 0 ;
12710 PyObject * obj1 = 0 ;
12711 PyObject * obj2 = 0 ;
12712 PyObject * obj3 = 0 ;
12713 PyObject * obj4 = 0 ;
12714 PyObject * obj5 = 0 ;
12715 PyObject * obj6 = 0 ;
12716 char *kwnames[] = {
12717 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12718 };
12719
12720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12722 if (SWIG_arg_fail(1)) SWIG_fail;
12723 {
12724 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12725 if (SWIG_arg_fail(2)) SWIG_fail;
12726 }
12727 {
12728 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12729 if (SWIG_arg_fail(3)) SWIG_fail;
12730 }
12731 {
12732 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12733 if (SWIG_arg_fail(4)) SWIG_fail;
12734 }
12735 {
12736 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12737 if (SWIG_arg_fail(5)) SWIG_fail;
12738 }
12739 {
12740 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12741 if (SWIG_arg_fail(6)) SWIG_fail;
12742 }
12743 {
12744 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12745 if (SWIG_arg_fail(7)) SWIG_fail;
12746 }
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12750
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 Py_INCREF(Py_None); resultobj = Py_None;
12755 return resultobj;
12756 fail:
12757 return NULL;
12758 }
12759
12760
12761 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj;
12763 wxImage *arg1 = (wxImage *) 0 ;
12764 unsigned char arg2 ;
12765 unsigned char arg3 ;
12766 unsigned char arg4 ;
12767 SwigValueWrapper<wxImage > result;
12768 PyObject * obj0 = 0 ;
12769 PyObject * obj1 = 0 ;
12770 PyObject * obj2 = 0 ;
12771 PyObject * obj3 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 {
12780 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12781 if (SWIG_arg_fail(2)) SWIG_fail;
12782 }
12783 {
12784 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12785 if (SWIG_arg_fail(3)) SWIG_fail;
12786 }
12787 {
12788 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12789 if (SWIG_arg_fail(4)) SWIG_fail;
12790 }
12791 {
12792 PyThreadState* __tstate = wxPyBeginAllowThreads();
12793 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12794
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 wxImage * resultptr;
12800 resultptr = new wxImage((wxImage &)(result));
12801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12802 }
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12810 PyObject *resultobj;
12811 wxImage *arg1 = (wxImage *) 0 ;
12812 wxString *arg2 = 0 ;
12813 wxString *arg3 = 0 ;
12814 bool temp2 = false ;
12815 bool temp3 = false ;
12816 PyObject * obj0 = 0 ;
12817 PyObject * obj1 = 0 ;
12818 PyObject * obj2 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "name",(char *) "value", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 arg2 = wxString_in_helper(obj1);
12828 if (arg2 == NULL) SWIG_fail;
12829 temp2 = true;
12830 }
12831 {
12832 arg3 = wxString_in_helper(obj2);
12833 if (arg3 == NULL) SWIG_fail;
12834 temp3 = true;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12839
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 Py_INCREF(Py_None); resultobj = Py_None;
12844 {
12845 if (temp2)
12846 delete arg2;
12847 }
12848 {
12849 if (temp3)
12850 delete arg3;
12851 }
12852 return resultobj;
12853 fail:
12854 {
12855 if (temp2)
12856 delete arg2;
12857 }
12858 {
12859 if (temp3)
12860 delete arg3;
12861 }
12862 return NULL;
12863 }
12864
12865
12866 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxImage *arg1 = (wxImage *) 0 ;
12869 wxString *arg2 = 0 ;
12870 int arg3 ;
12871 bool temp2 = false ;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 PyObject * obj2 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "name",(char *) "value", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = wxString_in_helper(obj1);
12884 if (arg2 == NULL) SWIG_fail;
12885 temp2 = true;
12886 }
12887 {
12888 arg3 = (int)(SWIG_As_int(obj2));
12889 if (SWIG_arg_fail(3)) SWIG_fail;
12890 }
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 (arg1)->SetOption((wxString const &)*arg2,arg3);
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 Py_INCREF(Py_None); resultobj = Py_None;
12899 {
12900 if (temp2)
12901 delete arg2;
12902 }
12903 return resultobj;
12904 fail:
12905 {
12906 if (temp2)
12907 delete arg2;
12908 }
12909 return NULL;
12910 }
12911
12912
12913 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12914 PyObject *resultobj;
12915 wxImage *arg1 = (wxImage *) 0 ;
12916 wxString *arg2 = 0 ;
12917 wxString result;
12918 bool temp2 = false ;
12919 PyObject * obj0 = 0 ;
12920 PyObject * obj1 = 0 ;
12921 char *kwnames[] = {
12922 (char *) "self",(char *) "name", NULL
12923 };
12924
12925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 {
12929 arg2 = wxString_in_helper(obj1);
12930 if (arg2 == NULL) SWIG_fail;
12931 temp2 = true;
12932 }
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12936
12937 wxPyEndAllowThreads(__tstate);
12938 if (PyErr_Occurred()) SWIG_fail;
12939 }
12940 {
12941 #if wxUSE_UNICODE
12942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12943 #else
12944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12945 #endif
12946 }
12947 {
12948 if (temp2)
12949 delete arg2;
12950 }
12951 return resultobj;
12952 fail:
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return NULL;
12958 }
12959
12960
12961 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12962 PyObject *resultobj;
12963 wxImage *arg1 = (wxImage *) 0 ;
12964 wxString *arg2 = 0 ;
12965 int result;
12966 bool temp2 = false ;
12967 PyObject * obj0 = 0 ;
12968 PyObject * obj1 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self",(char *) "name", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 arg2 = wxString_in_helper(obj1);
12978 if (arg2 == NULL) SWIG_fail;
12979 temp2 = true;
12980 }
12981 {
12982 PyThreadState* __tstate = wxPyBeginAllowThreads();
12983 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12984
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 resultobj = SWIG_From_int((int)(result));
12990 }
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return resultobj;
12996 fail:
12997 {
12998 if (temp2)
12999 delete arg2;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxImage *arg1 = (wxImage *) 0 ;
13008 wxString *arg2 = 0 ;
13009 bool result;
13010 bool temp2 = false ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self",(char *) "name", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",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 {
13021 arg2 = wxString_in_helper(obj1);
13022 if (arg2 == NULL) SWIG_fail;
13023 temp2 = true;
13024 }
13025 {
13026 PyThreadState* __tstate = wxPyBeginAllowThreads();
13027 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13028
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 {
13033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13034 }
13035 {
13036 if (temp2)
13037 delete arg2;
13038 }
13039 return resultobj;
13040 fail:
13041 {
13042 if (temp2)
13043 delete arg2;
13044 }
13045 return NULL;
13046 }
13047
13048
13049 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj;
13051 wxImage *arg1 = (wxImage *) 0 ;
13052 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13053 unsigned long result;
13054 PyObject * obj0 = 0 ;
13055 PyObject * obj1 = 0 ;
13056 char *kwnames[] = {
13057 (char *) "self",(char *) "stopafter", NULL
13058 };
13059
13060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13062 if (SWIG_arg_fail(1)) SWIG_fail;
13063 if (obj1) {
13064 {
13065 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13066 if (SWIG_arg_fail(2)) SWIG_fail;
13067 }
13068 }
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 result = (unsigned long)(arg1)->CountColours(arg2);
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 {
13077 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13078 }
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13086 PyObject *resultobj;
13087 wxImage *arg1 = (wxImage *) 0 ;
13088 wxImageHistogram *arg2 = 0 ;
13089 unsigned long result;
13090 PyObject * obj0 = 0 ;
13091 PyObject * obj1 = 0 ;
13092 char *kwnames[] = {
13093 (char *) "self",(char *) "h", NULL
13094 };
13095
13096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13098 if (SWIG_arg_fail(1)) SWIG_fail;
13099 {
13100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13101 if (SWIG_arg_fail(2)) SWIG_fail;
13102 if (arg2 == NULL) {
13103 SWIG_null_ref("wxImageHistogram");
13104 }
13105 if (SWIG_arg_fail(2)) SWIG_fail;
13106 }
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13110
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 {
13115 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13116 }
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13126 PyObject * obj0 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "handler", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 wxImage::AddHandler(arg1);
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 Py_INCREF(Py_None); resultobj = Py_None;
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj;
13150 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13151 PyObject * obj0 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "handler", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 wxImage::InsertHandler(arg1);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 Py_INCREF(Py_None); resultobj = Py_None;
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj;
13175 wxString *arg1 = 0 ;
13176 bool result;
13177 bool temp1 = false ;
13178 PyObject * obj0 = 0 ;
13179 char *kwnames[] = {
13180 (char *) "name", NULL
13181 };
13182
13183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13184 {
13185 arg1 = wxString_in_helper(obj0);
13186 if (arg1 == NULL) SWIG_fail;
13187 temp1 = true;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 {
13197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13198 }
13199 {
13200 if (temp1)
13201 delete arg1;
13202 }
13203 return resultobj;
13204 fail:
13205 {
13206 if (temp1)
13207 delete arg1;
13208 }
13209 return NULL;
13210 }
13211
13212
13213 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13214 PyObject *resultobj;
13215 wxString result;
13216 char *kwnames[] = {
13217 NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 result = wxImage::GetImageExtWildcard();
13224
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 {
13229 #if wxUSE_UNICODE
13230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13231 #else
13232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13233 #endif
13234 }
13235 return resultobj;
13236 fail:
13237 return NULL;
13238 }
13239
13240
13241 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj;
13243 wxImage *arg1 = (wxImage *) 0 ;
13244 int arg2 = (int) -1 ;
13245 wxBitmap result;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 char *kwnames[] = {
13249 (char *) "self",(char *) "depth", NULL
13250 };
13251
13252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13254 if (SWIG_arg_fail(1)) SWIG_fail;
13255 if (obj1) {
13256 {
13257 arg2 = (int)(SWIG_As_int(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 }
13261 {
13262 if (!wxPyCheckForApp()) SWIG_fail;
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 result = wxImage_ConvertToBitmap(arg1,arg2);
13265
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 {
13270 wxBitmap * resultptr;
13271 resultptr = new wxBitmap((wxBitmap &)(result));
13272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13273 }
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxImage *arg1 = (wxImage *) 0 ;
13283 unsigned char arg2 ;
13284 unsigned char arg3 ;
13285 unsigned char arg4 ;
13286 wxBitmap result;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 PyObject * obj2 = 0 ;
13290 PyObject * obj3 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 {
13299 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13300 if (SWIG_arg_fail(2)) SWIG_fail;
13301 }
13302 {
13303 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13304 if (SWIG_arg_fail(3)) SWIG_fail;
13305 }
13306 {
13307 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13308 if (SWIG_arg_fail(4)) SWIG_fail;
13309 }
13310 {
13311 if (!wxPyCheckForApp()) SWIG_fail;
13312 PyThreadState* __tstate = wxPyBeginAllowThreads();
13313 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13314
13315 wxPyEndAllowThreads(__tstate);
13316 if (PyErr_Occurred()) SWIG_fail;
13317 }
13318 {
13319 wxBitmap * resultptr;
13320 resultptr = new wxBitmap((wxBitmap &)(result));
13321 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13322 }
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13330 PyObject *obj;
13331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13332 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13333 Py_INCREF(obj);
13334 return Py_BuildValue((char *)"");
13335 }
13336 static int _wrap_NullImage_set(PyObject *) {
13337 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13338 return 1;
13339 }
13340
13341
13342 static PyObject *_wrap_NullImage_get(void) {
13343 PyObject *pyobj;
13344
13345 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13346 return pyobj;
13347 }
13348
13349
13350 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13351 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13352 return 1;
13353 }
13354
13355
13356 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13357 PyObject *pyobj;
13358
13359 {
13360 #if wxUSE_UNICODE
13361 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13362 #else
13363 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13364 #endif
13365 }
13366 return pyobj;
13367 }
13368
13369
13370 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13371 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13372 return 1;
13373 }
13374
13375
13376 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13377 PyObject *pyobj;
13378
13379 {
13380 #if wxUSE_UNICODE
13381 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13382 #else
13383 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13384 #endif
13385 }
13386 return pyobj;
13387 }
13388
13389
13390 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13391 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13392 return 1;
13393 }
13394
13395
13396 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13397 PyObject *pyobj;
13398
13399 {
13400 #if wxUSE_UNICODE
13401 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13402 #else
13403 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13404 #endif
13405 }
13406 return pyobj;
13407 }
13408
13409
13410 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13411 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13412 return 1;
13413 }
13414
13415
13416 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13417 PyObject *pyobj;
13418
13419 {
13420 #if wxUSE_UNICODE
13421 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13422 #else
13423 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13424 #endif
13425 }
13426 return pyobj;
13427 }
13428
13429
13430 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13431 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13432 return 1;
13433 }
13434
13435
13436 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13437 PyObject *pyobj;
13438
13439 {
13440 #if wxUSE_UNICODE
13441 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13442 #else
13443 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13444 #endif
13445 }
13446 return pyobj;
13447 }
13448
13449
13450 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj;
13452 wxBMPHandler *result;
13453 char *kwnames[] = {
13454 NULL
13455 };
13456
13457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13458 {
13459 PyThreadState* __tstate = wxPyBeginAllowThreads();
13460 result = (wxBMPHandler *)new wxBMPHandler();
13461
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13466 return resultobj;
13467 fail:
13468 return NULL;
13469 }
13470
13471
13472 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13473 PyObject *obj;
13474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13475 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13476 Py_INCREF(obj);
13477 return Py_BuildValue((char *)"");
13478 }
13479 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13480 PyObject *resultobj;
13481 wxICOHandler *result;
13482 char *kwnames[] = {
13483 NULL
13484 };
13485
13486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (wxICOHandler *)new wxICOHandler();
13490
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13502 PyObject *obj;
13503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13504 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13505 Py_INCREF(obj);
13506 return Py_BuildValue((char *)"");
13507 }
13508 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj;
13510 wxCURHandler *result;
13511 char *kwnames[] = {
13512 NULL
13513 };
13514
13515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = (wxCURHandler *)new wxCURHandler();
13519
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13531 PyObject *obj;
13532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13533 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13534 Py_INCREF(obj);
13535 return Py_BuildValue((char *)"");
13536 }
13537 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxANIHandler *result;
13540 char *kwnames[] = {
13541 NULL
13542 };
13543
13544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = (wxANIHandler *)new wxANIHandler();
13548
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13560 PyObject *obj;
13561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13562 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13563 Py_INCREF(obj);
13564 return Py_BuildValue((char *)"");
13565 }
13566 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13567 PyObject *resultobj;
13568 wxPNGHandler *result;
13569 char *kwnames[] = {
13570 NULL
13571 };
13572
13573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (wxPNGHandler *)new wxPNGHandler();
13577
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13589 PyObject *obj;
13590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13591 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13592 Py_INCREF(obj);
13593 return Py_BuildValue((char *)"");
13594 }
13595 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj;
13597 wxGIFHandler *result;
13598 char *kwnames[] = {
13599 NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (wxGIFHandler *)new wxGIFHandler();
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13611 return resultobj;
13612 fail:
13613 return NULL;
13614 }
13615
13616
13617 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13618 PyObject *obj;
13619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13620 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13621 Py_INCREF(obj);
13622 return Py_BuildValue((char *)"");
13623 }
13624 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj;
13626 wxPCXHandler *result;
13627 char *kwnames[] = {
13628 NULL
13629 };
13630
13631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 result = (wxPCXHandler *)new wxPCXHandler();
13635
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13647 PyObject *obj;
13648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13649 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13650 Py_INCREF(obj);
13651 return Py_BuildValue((char *)"");
13652 }
13653 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxJPEGHandler *result;
13656 char *kwnames[] = {
13657 NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 result = (wxJPEGHandler *)new wxJPEGHandler();
13664
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13676 PyObject *obj;
13677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13678 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13679 Py_INCREF(obj);
13680 return Py_BuildValue((char *)"");
13681 }
13682 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj;
13684 wxPNMHandler *result;
13685 char *kwnames[] = {
13686 NULL
13687 };
13688
13689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13690 {
13691 PyThreadState* __tstate = wxPyBeginAllowThreads();
13692 result = (wxPNMHandler *)new wxPNMHandler();
13693
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13705 PyObject *obj;
13706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13707 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13708 Py_INCREF(obj);
13709 return Py_BuildValue((char *)"");
13710 }
13711 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj;
13713 wxXPMHandler *result;
13714 char *kwnames[] = {
13715 NULL
13716 };
13717
13718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 result = (wxXPMHandler *)new wxXPMHandler();
13722
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13734 PyObject *obj;
13735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13736 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13737 Py_INCREF(obj);
13738 return Py_BuildValue((char *)"");
13739 }
13740 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj;
13742 wxTIFFHandler *result;
13743 char *kwnames[] = {
13744 NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 result = (wxTIFFHandler *)new wxTIFFHandler();
13751
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13763 PyObject *obj;
13764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13765 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13766 Py_INCREF(obj);
13767 return Py_BuildValue((char *)"");
13768 }
13769 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj;
13771 wxImage *arg1 = 0 ;
13772 wxImage *arg2 = 0 ;
13773 int arg3 = (int) 236 ;
13774 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13775 bool result;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 PyObject * obj2 = 0 ;
13779 PyObject * obj3 = 0 ;
13780 char *kwnames[] = {
13781 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13782 };
13783
13784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13785 {
13786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13787 if (SWIG_arg_fail(1)) SWIG_fail;
13788 if (arg1 == NULL) {
13789 SWIG_null_ref("wxImage");
13790 }
13791 if (SWIG_arg_fail(1)) SWIG_fail;
13792 }
13793 {
13794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13795 if (SWIG_arg_fail(2)) SWIG_fail;
13796 if (arg2 == NULL) {
13797 SWIG_null_ref("wxImage");
13798 }
13799 if (SWIG_arg_fail(2)) SWIG_fail;
13800 }
13801 if (obj2) {
13802 {
13803 arg3 = (int)(SWIG_As_int(obj2));
13804 if (SWIG_arg_fail(3)) SWIG_fail;
13805 }
13806 }
13807 if (obj3) {
13808 {
13809 arg4 = (int)(SWIG_As_int(obj3));
13810 if (SWIG_arg_fail(4)) SWIG_fail;
13811 }
13812 }
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 {
13821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13822 }
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13830 PyObject *obj;
13831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13832 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13833 Py_INCREF(obj);
13834 return Py_BuildValue((char *)"");
13835 }
13836 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13837 PyObject *resultobj;
13838 wxEvtHandler *result;
13839 char *kwnames[] = {
13840 NULL
13841 };
13842
13843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 result = (wxEvtHandler *)new wxEvtHandler();
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13861 wxEvtHandler *result;
13862 PyObject * obj0 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self", NULL
13865 };
13866
13867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13869 if (SWIG_arg_fail(1)) SWIG_fail;
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13873
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 {
13878 resultobj = wxPyMake_wxObject(result, 0);
13879 }
13880 return resultobj;
13881 fail:
13882 return NULL;
13883 }
13884
13885
13886 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj;
13888 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13889 wxEvtHandler *result;
13890 PyObject * obj0 = 0 ;
13891 char *kwnames[] = {
13892 (char *) "self", NULL
13893 };
13894
13895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13897 if (SWIG_arg_fail(1)) SWIG_fail;
13898 {
13899 PyThreadState* __tstate = wxPyBeginAllowThreads();
13900 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13901
13902 wxPyEndAllowThreads(__tstate);
13903 if (PyErr_Occurred()) SWIG_fail;
13904 }
13905 {
13906 resultobj = wxPyMake_wxObject(result, 0);
13907 }
13908 return resultobj;
13909 fail:
13910 return NULL;
13911 }
13912
13913
13914 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13915 PyObject *resultobj;
13916 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13917 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13918 PyObject * obj0 = 0 ;
13919 PyObject * obj1 = 0 ;
13920 char *kwnames[] = {
13921 (char *) "self",(char *) "handler", NULL
13922 };
13923
13924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13926 if (SWIG_arg_fail(1)) SWIG_fail;
13927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(2)) SWIG_fail;
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 (arg1)->SetNextHandler(arg2);
13932
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 Py_INCREF(Py_None); resultobj = Py_None;
13937 return resultobj;
13938 fail:
13939 return NULL;
13940 }
13941
13942
13943 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13944 PyObject *resultobj;
13945 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13946 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13947 PyObject * obj0 = 0 ;
13948 PyObject * obj1 = 0 ;
13949 char *kwnames[] = {
13950 (char *) "self",(char *) "handler", NULL
13951 };
13952
13953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13955 if (SWIG_arg_fail(1)) SWIG_fail;
13956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13957 if (SWIG_arg_fail(2)) SWIG_fail;
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 (arg1)->SetPreviousHandler(arg2);
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 Py_INCREF(Py_None); resultobj = Py_None;
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13973 PyObject *resultobj;
13974 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13975 bool result;
13976 PyObject * obj0 = 0 ;
13977 char *kwnames[] = {
13978 (char *) "self", NULL
13979 };
13980
13981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13983 if (SWIG_arg_fail(1)) SWIG_fail;
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 result = (bool)(arg1)->GetEvtHandlerEnabled();
13987
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 {
13992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13993 }
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14001 PyObject *resultobj;
14002 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14003 bool arg2 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 char *kwnames[] = {
14007 (char *) "self",(char *) "enabled", NULL
14008 };
14009
14010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14012 if (SWIG_arg_fail(1)) SWIG_fail;
14013 {
14014 arg2 = (bool)(SWIG_As_bool(obj1));
14015 if (SWIG_arg_fail(2)) SWIG_fail;
14016 }
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 (arg1)->SetEvtHandlerEnabled(arg2);
14020
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 Py_INCREF(Py_None); resultobj = Py_None;
14025 return resultobj;
14026 fail:
14027 return NULL;
14028 }
14029
14030
14031 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14032 PyObject *resultobj;
14033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14034 wxEvent *arg2 = 0 ;
14035 bool result;
14036 PyObject * obj0 = 0 ;
14037 PyObject * obj1 = 0 ;
14038 char *kwnames[] = {
14039 (char *) "self",(char *) "event", NULL
14040 };
14041
14042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14044 if (SWIG_arg_fail(1)) SWIG_fail;
14045 {
14046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(2)) SWIG_fail;
14048 if (arg2 == NULL) {
14049 SWIG_null_ref("wxEvent");
14050 }
14051 if (SWIG_arg_fail(2)) SWIG_fail;
14052 }
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 result = (bool)(arg1)->ProcessEvent(*arg2);
14056
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 {
14061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14062 }
14063 return resultobj;
14064 fail:
14065 return NULL;
14066 }
14067
14068
14069 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14070 PyObject *resultobj;
14071 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14072 wxEvent *arg2 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 char *kwnames[] = {
14076 (char *) "self",(char *) "event", NULL
14077 };
14078
14079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(1)) SWIG_fail;
14082 {
14083 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14084 if (SWIG_arg_fail(2)) SWIG_fail;
14085 if (arg2 == NULL) {
14086 SWIG_null_ref("wxEvent");
14087 }
14088 if (SWIG_arg_fail(2)) SWIG_fail;
14089 }
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 (arg1)->AddPendingEvent(*arg2);
14093
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 Py_INCREF(Py_None); resultobj = Py_None;
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj;
14106 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14107 PyObject * obj0 = 0 ;
14108 char *kwnames[] = {
14109 (char *) "self", NULL
14110 };
14111
14112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14114 if (SWIG_arg_fail(1)) SWIG_fail;
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 (arg1)->ProcessPendingEvents();
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 Py_INCREF(Py_None); resultobj = Py_None;
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14132 int arg2 ;
14133 int arg3 ;
14134 int arg4 ;
14135 PyObject *arg5 = (PyObject *) 0 ;
14136 PyObject * obj0 = 0 ;
14137 PyObject * obj1 = 0 ;
14138 PyObject * obj2 = 0 ;
14139 PyObject * obj3 = 0 ;
14140 PyObject * obj4 = 0 ;
14141 char *kwnames[] = {
14142 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14143 };
14144
14145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14147 if (SWIG_arg_fail(1)) SWIG_fail;
14148 {
14149 arg2 = (int)(SWIG_As_int(obj1));
14150 if (SWIG_arg_fail(2)) SWIG_fail;
14151 }
14152 {
14153 arg3 = (int)(SWIG_As_int(obj2));
14154 if (SWIG_arg_fail(3)) SWIG_fail;
14155 }
14156 {
14157 arg4 = (int)(SWIG_As_int(obj3));
14158 if (SWIG_arg_fail(4)) SWIG_fail;
14159 }
14160 arg5 = obj4;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 Py_INCREF(Py_None); resultobj = Py_None;
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14178 int arg2 ;
14179 int arg3 = (int) -1 ;
14180 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14181 bool result;
14182 PyObject * obj0 = 0 ;
14183 PyObject * obj1 = 0 ;
14184 PyObject * obj2 = 0 ;
14185 PyObject * obj3 = 0 ;
14186 char *kwnames[] = {
14187 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14188 };
14189
14190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14192 if (SWIG_arg_fail(1)) SWIG_fail;
14193 {
14194 arg2 = (int)(SWIG_As_int(obj1));
14195 if (SWIG_arg_fail(2)) SWIG_fail;
14196 }
14197 if (obj2) {
14198 {
14199 arg3 = (int)(SWIG_As_int(obj2));
14200 if (SWIG_arg_fail(3)) SWIG_fail;
14201 }
14202 }
14203 if (obj3) {
14204 {
14205 arg4 = (wxEventType)(SWIG_As_int(obj3));
14206 if (SWIG_arg_fail(4)) SWIG_fail;
14207 }
14208 }
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14218 }
14219 return resultobj;
14220 fail:
14221 return NULL;
14222 }
14223
14224
14225 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj;
14227 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14228 PyObject *arg2 = (PyObject *) 0 ;
14229 bool arg3 = (bool) true ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 PyObject * obj2 = 0 ;
14233 char *kwnames[] = {
14234 (char *) "self",(char *) "_self",(char *) "incref", NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 arg2 = obj1;
14241 if (obj2) {
14242 {
14243 arg3 = (bool)(SWIG_As_bool(obj2));
14244 if (SWIG_arg_fail(3)) SWIG_fail;
14245 }
14246 }
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 Py_INCREF(Py_None); resultobj = Py_None;
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14262 PyObject *obj;
14263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14264 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14265 Py_INCREF(obj);
14266 return Py_BuildValue((char *)"");
14267 }
14268 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxEventType result;
14271 char *kwnames[] = {
14272 NULL
14273 };
14274
14275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (wxEventType)wxNewEventType();
14279
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 {
14284 resultobj = SWIG_From_int((int)(result));
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj;
14294 wxEvent *arg1 = (wxEvent *) 0 ;
14295 PyObject * obj0 = 0 ;
14296 char *kwnames[] = {
14297 (char *) "self", NULL
14298 };
14299
14300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14302 if (SWIG_arg_fail(1)) SWIG_fail;
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 delete arg1;
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 Py_INCREF(Py_None); resultobj = Py_None;
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14318 PyObject *resultobj;
14319 wxEvent *arg1 = (wxEvent *) 0 ;
14320 wxEventType arg2 ;
14321 PyObject * obj0 = 0 ;
14322 PyObject * obj1 = 0 ;
14323 char *kwnames[] = {
14324 (char *) "self",(char *) "typ", NULL
14325 };
14326
14327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14329 if (SWIG_arg_fail(1)) SWIG_fail;
14330 {
14331 arg2 = (wxEventType)(SWIG_As_int(obj1));
14332 if (SWIG_arg_fail(2)) SWIG_fail;
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 (arg1)->SetEventType(arg2);
14337
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 Py_INCREF(Py_None); resultobj = Py_None;
14342 return resultobj;
14343 fail:
14344 return NULL;
14345 }
14346
14347
14348 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14349 PyObject *resultobj;
14350 wxEvent *arg1 = (wxEvent *) 0 ;
14351 wxEventType result;
14352 PyObject * obj0 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14363
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 {
14368 resultobj = SWIG_From_int((int)(result));
14369 }
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj;
14378 wxEvent *arg1 = (wxEvent *) 0 ;
14379 wxObject *result;
14380 PyObject * obj0 = 0 ;
14381 char *kwnames[] = {
14382 (char *) "self", NULL
14383 };
14384
14385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14387 if (SWIG_arg_fail(1)) SWIG_fail;
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14391
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = wxPyMake_wxObject(result, 0);
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj;
14406 wxEvent *arg1 = (wxEvent *) 0 ;
14407 wxObject *arg2 = (wxObject *) 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "obj", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(2)) SWIG_fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 (arg1)->SetEventObject(arg2);
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 Py_INCREF(Py_None); resultobj = Py_None;
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj;
14435 wxEvent *arg1 = (wxEvent *) 0 ;
14436 long result;
14437 PyObject * obj0 = 0 ;
14438 char *kwnames[] = {
14439 (char *) "self", NULL
14440 };
14441
14442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14444 if (SWIG_arg_fail(1)) SWIG_fail;
14445 {
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14448
14449 wxPyEndAllowThreads(__tstate);
14450 if (PyErr_Occurred()) SWIG_fail;
14451 }
14452 {
14453 resultobj = SWIG_From_long((long)(result));
14454 }
14455 return resultobj;
14456 fail:
14457 return NULL;
14458 }
14459
14460
14461 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14462 PyObject *resultobj;
14463 wxEvent *arg1 = (wxEvent *) 0 ;
14464 long arg2 = (long) 0 ;
14465 PyObject * obj0 = 0 ;
14466 PyObject * obj1 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self",(char *) "ts", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 if (obj1) {
14475 {
14476 arg2 = (long)(SWIG_As_long(obj1));
14477 if (SWIG_arg_fail(2)) SWIG_fail;
14478 }
14479 }
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 (arg1)->SetTimestamp(arg2);
14483
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 Py_INCREF(Py_None); resultobj = Py_None;
14488 return resultobj;
14489 fail:
14490 return NULL;
14491 }
14492
14493
14494 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14495 PyObject *resultobj;
14496 wxEvent *arg1 = (wxEvent *) 0 ;
14497 int result;
14498 PyObject * obj0 = 0 ;
14499 char *kwnames[] = {
14500 (char *) "self", NULL
14501 };
14502
14503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14505 if (SWIG_arg_fail(1)) SWIG_fail;
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 result = (int)((wxEvent const *)arg1)->GetId();
14509
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 {
14514 resultobj = SWIG_From_int((int)(result));
14515 }
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj;
14524 wxEvent *arg1 = (wxEvent *) 0 ;
14525 int arg2 ;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 char *kwnames[] = {
14529 (char *) "self",(char *) "Id", NULL
14530 };
14531
14532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14534 if (SWIG_arg_fail(1)) SWIG_fail;
14535 {
14536 arg2 = (int)(SWIG_As_int(obj1));
14537 if (SWIG_arg_fail(2)) SWIG_fail;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 (arg1)->SetId(arg2);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 Py_INCREF(Py_None); resultobj = Py_None;
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxEvent *arg1 = (wxEvent *) 0 ;
14556 bool result;
14557 PyObject * obj0 = 0 ;
14558 char *kwnames[] = {
14559 (char *) "self", NULL
14560 };
14561
14562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14564 if (SWIG_arg_fail(1)) SWIG_fail;
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14568
14569 wxPyEndAllowThreads(__tstate);
14570 if (PyErr_Occurred()) SWIG_fail;
14571 }
14572 {
14573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14574 }
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14582 PyObject *resultobj;
14583 wxEvent *arg1 = (wxEvent *) 0 ;
14584 bool arg2 = (bool) true ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self",(char *) "skip", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 if (obj1) {
14595 {
14596 arg2 = (bool)(SWIG_As_bool(obj1));
14597 if (SWIG_arg_fail(2)) SWIG_fail;
14598 }
14599 }
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 (arg1)->Skip(arg2);
14603
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 Py_INCREF(Py_None); resultobj = Py_None;
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxEvent *arg1 = (wxEvent *) 0 ;
14617 bool result;
14618 PyObject * obj0 = 0 ;
14619 char *kwnames[] = {
14620 (char *) "self", NULL
14621 };
14622
14623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14625 if (SWIG_arg_fail(1)) SWIG_fail;
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14629
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 {
14634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14635 }
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj;
14644 wxEvent *arg1 = (wxEvent *) 0 ;
14645 bool result;
14646 PyObject * obj0 = 0 ;
14647 char *kwnames[] = {
14648 (char *) "self", NULL
14649 };
14650
14651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14653 if (SWIG_arg_fail(1)) SWIG_fail;
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14663 }
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj;
14672 wxEvent *arg1 = (wxEvent *) 0 ;
14673 int result;
14674 PyObject * obj0 = 0 ;
14675 char *kwnames[] = {
14676 (char *) "self", NULL
14677 };
14678
14679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14681 if (SWIG_arg_fail(1)) SWIG_fail;
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 result = (int)(arg1)->StopPropagation();
14685
14686 wxPyEndAllowThreads(__tstate);
14687 if (PyErr_Occurred()) SWIG_fail;
14688 }
14689 {
14690 resultobj = SWIG_From_int((int)(result));
14691 }
14692 return resultobj;
14693 fail:
14694 return NULL;
14695 }
14696
14697
14698 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj;
14700 wxEvent *arg1 = (wxEvent *) 0 ;
14701 int arg2 ;
14702 PyObject * obj0 = 0 ;
14703 PyObject * obj1 = 0 ;
14704 char *kwnames[] = {
14705 (char *) "self",(char *) "propagationLevel", NULL
14706 };
14707
14708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14710 if (SWIG_arg_fail(1)) SWIG_fail;
14711 {
14712 arg2 = (int)(SWIG_As_int(obj1));
14713 if (SWIG_arg_fail(2)) SWIG_fail;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->ResumePropagation(arg2);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 Py_INCREF(Py_None); resultobj = Py_None;
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14730 PyObject *resultobj;
14731 wxEvent *arg1 = (wxEvent *) 0 ;
14732 wxEvent *result;
14733 PyObject * obj0 = 0 ;
14734 char *kwnames[] = {
14735 (char *) "self", NULL
14736 };
14737
14738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(1)) SWIG_fail;
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (wxEvent *)(arg1)->Clone();
14744
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14749 return resultobj;
14750 fail:
14751 return NULL;
14752 }
14753
14754
14755 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14756 PyObject *obj;
14757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14758 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14759 Py_INCREF(obj);
14760 return Py_BuildValue((char *)"");
14761 }
14762 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14763 PyObject *resultobj;
14764 wxEvent *arg1 = 0 ;
14765 wxPropagationDisabler *result;
14766 PyObject * obj0 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "event", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14772 {
14773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14774 if (SWIG_arg_fail(1)) SWIG_fail;
14775 if (arg1 == NULL) {
14776 SWIG_null_ref("wxEvent");
14777 }
14778 if (SWIG_arg_fail(1)) SWIG_fail;
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14797 PyObject * obj0 = 0 ;
14798 char *kwnames[] = {
14799 (char *) "self", NULL
14800 };
14801
14802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14804 if (SWIG_arg_fail(1)) SWIG_fail;
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 delete arg1;
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 Py_INCREF(Py_None); resultobj = Py_None;
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14820 PyObject *obj;
14821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14822 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14823 Py_INCREF(obj);
14824 return Py_BuildValue((char *)"");
14825 }
14826 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj;
14828 wxEvent *arg1 = 0 ;
14829 wxPropagateOnce *result;
14830 PyObject * obj0 = 0 ;
14831 char *kwnames[] = {
14832 (char *) "event", NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14836 {
14837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14838 if (SWIG_arg_fail(1)) SWIG_fail;
14839 if (arg1 == NULL) {
14840 SWIG_null_ref("wxEvent");
14841 }
14842 if (SWIG_arg_fail(1)) SWIG_fail;
14843 }
14844 {
14845 PyThreadState* __tstate = wxPyBeginAllowThreads();
14846 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14847
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14852 return resultobj;
14853 fail:
14854 return NULL;
14855 }
14856
14857
14858 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj;
14860 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14861 PyObject * obj0 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "self", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14868 if (SWIG_arg_fail(1)) SWIG_fail;
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 delete arg1;
14872
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 Py_INCREF(Py_None); resultobj = Py_None;
14877 return resultobj;
14878 fail:
14879 return NULL;
14880 }
14881
14882
14883 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14884 PyObject *obj;
14885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14886 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14887 Py_INCREF(obj);
14888 return Py_BuildValue((char *)"");
14889 }
14890 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj;
14892 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14893 int arg2 = (int) 0 ;
14894 wxCommandEvent *result;
14895 PyObject * obj0 = 0 ;
14896 PyObject * obj1 = 0 ;
14897 char *kwnames[] = {
14898 (char *) "commandType",(char *) "winid", NULL
14899 };
14900
14901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14902 if (obj0) {
14903 {
14904 arg1 = (wxEventType)(SWIG_As_int(obj0));
14905 if (SWIG_arg_fail(1)) SWIG_fail;
14906 }
14907 }
14908 if (obj1) {
14909 {
14910 arg2 = (int)(SWIG_As_int(obj1));
14911 if (SWIG_arg_fail(2)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14929 PyObject *resultobj;
14930 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14931 int result;
14932 PyObject * obj0 = 0 ;
14933 char *kwnames[] = {
14934 (char *) "self", NULL
14935 };
14936
14937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14939 if (SWIG_arg_fail(1)) SWIG_fail;
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 {
14948 resultobj = SWIG_From_int((int)(result));
14949 }
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14959 wxString *arg2 = 0 ;
14960 bool temp2 = false ;
14961 PyObject * obj0 = 0 ;
14962 PyObject * obj1 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "self",(char *) "s", NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14969 if (SWIG_arg_fail(1)) SWIG_fail;
14970 {
14971 arg2 = wxString_in_helper(obj1);
14972 if (arg2 == NULL) SWIG_fail;
14973 temp2 = true;
14974 }
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 (arg1)->SetString((wxString const &)*arg2);
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 Py_INCREF(Py_None); resultobj = Py_None;
14983 {
14984 if (temp2)
14985 delete arg2;
14986 }
14987 return resultobj;
14988 fail:
14989 {
14990 if (temp2)
14991 delete arg2;
14992 }
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15000 wxString result;
15001 PyObject * obj0 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self", NULL
15004 };
15005
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 PyThreadState* __tstate = wxPyBeginAllowThreads();
15011 result = ((wxCommandEvent const *)arg1)->GetString();
15012
15013 wxPyEndAllowThreads(__tstate);
15014 if (PyErr_Occurred()) SWIG_fail;
15015 }
15016 {
15017 #if wxUSE_UNICODE
15018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15019 #else
15020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15021 #endif
15022 }
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15030 PyObject *resultobj;
15031 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15032 bool result;
15033 PyObject * obj0 = 0 ;
15034 char *kwnames[] = {
15035 (char *) "self", NULL
15036 };
15037
15038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15040 if (SWIG_arg_fail(1)) SWIG_fail;
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 {
15049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15050 }
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15058 PyObject *resultobj;
15059 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15060 bool result;
15061 PyObject * obj0 = 0 ;
15062 char *kwnames[] = {
15063 (char *) "self", NULL
15064 };
15065
15066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15068 if (SWIG_arg_fail(1)) SWIG_fail;
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15072
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 {
15077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15078 }
15079 return resultobj;
15080 fail:
15081 return NULL;
15082 }
15083
15084
15085 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15086 PyObject *resultobj;
15087 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15088 long arg2 ;
15089 PyObject * obj0 = 0 ;
15090 PyObject * obj1 = 0 ;
15091 char *kwnames[] = {
15092 (char *) "self",(char *) "extraLong", NULL
15093 };
15094
15095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15097 if (SWIG_arg_fail(1)) SWIG_fail;
15098 {
15099 arg2 = (long)(SWIG_As_long(obj1));
15100 if (SWIG_arg_fail(2)) SWIG_fail;
15101 }
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 (arg1)->SetExtraLong(arg2);
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 Py_INCREF(Py_None); resultobj = Py_None;
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15119 long result;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 {
15136 resultobj = SWIG_From_long((long)(result));
15137 }
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15147 int arg2 ;
15148 PyObject * obj0 = 0 ;
15149 PyObject * obj1 = 0 ;
15150 char *kwnames[] = {
15151 (char *) "self",(char *) "i", NULL
15152 };
15153
15154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(1)) SWIG_fail;
15157 {
15158 arg2 = (int)(SWIG_As_int(obj1));
15159 if (SWIG_arg_fail(2)) SWIG_fail;
15160 }
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 (arg1)->SetInt(arg2);
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 Py_INCREF(Py_None); resultobj = Py_None;
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj;
15177 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15178 long result;
15179 PyObject * obj0 = 0 ;
15180 char *kwnames[] = {
15181 (char *) "self", NULL
15182 };
15183
15184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15186 if (SWIG_arg_fail(1)) SWIG_fail;
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 {
15195 resultobj = SWIG_From_long((long)(result));
15196 }
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj;
15205 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15206 wxEvent *result;
15207 PyObject * obj0 = 0 ;
15208 char *kwnames[] = {
15209 (char *) "self", NULL
15210 };
15211
15212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15214 if (SWIG_arg_fail(1)) SWIG_fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15230 PyObject *obj;
15231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15232 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15233 Py_INCREF(obj);
15234 return Py_BuildValue((char *)"");
15235 }
15236 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15239 int arg2 = (int) 0 ;
15240 wxNotifyEvent *result;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 char *kwnames[] = {
15244 (char *) "commandType",(char *) "winid", NULL
15245 };
15246
15247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15248 if (obj0) {
15249 {
15250 arg1 = (wxEventType)(SWIG_As_int(obj0));
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 }
15253 }
15254 if (obj1) {
15255 {
15256 arg2 = (int)(SWIG_As_int(obj1));
15257 if (SWIG_arg_fail(2)) SWIG_fail;
15258 }
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15277 PyObject * obj0 = 0 ;
15278 char *kwnames[] = {
15279 (char *) "self", NULL
15280 };
15281
15282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15284 if (SWIG_arg_fail(1)) SWIG_fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 (arg1)->Veto();
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 Py_INCREF(Py_None); resultobj = Py_None;
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj;
15301 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15302 PyObject * obj0 = 0 ;
15303 char *kwnames[] = {
15304 (char *) "self", NULL
15305 };
15306
15307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15309 if (SWIG_arg_fail(1)) SWIG_fail;
15310 {
15311 PyThreadState* __tstate = wxPyBeginAllowThreads();
15312 (arg1)->Allow();
15313
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 Py_INCREF(Py_None); resultobj = Py_None;
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15325 PyObject *resultobj;
15326 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15327 bool result;
15328 PyObject * obj0 = 0 ;
15329 char *kwnames[] = {
15330 (char *) "self", NULL
15331 };
15332
15333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15335 if (SWIG_arg_fail(1)) SWIG_fail;
15336 {
15337 PyThreadState* __tstate = wxPyBeginAllowThreads();
15338 result = (bool)(arg1)->IsAllowed();
15339
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 {
15344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15345 }
15346 return resultobj;
15347 fail:
15348 return NULL;
15349 }
15350
15351
15352 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15353 PyObject *obj;
15354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15355 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15356 Py_INCREF(obj);
15357 return Py_BuildValue((char *)"");
15358 }
15359 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj;
15361 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15362 int arg2 = (int) 0 ;
15363 int arg3 = (int) 0 ;
15364 int arg4 = (int) 0 ;
15365 wxScrollEvent *result;
15366 PyObject * obj0 = 0 ;
15367 PyObject * obj1 = 0 ;
15368 PyObject * obj2 = 0 ;
15369 PyObject * obj3 = 0 ;
15370 char *kwnames[] = {
15371 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15372 };
15373
15374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15375 if (obj0) {
15376 {
15377 arg1 = (wxEventType)(SWIG_As_int(obj0));
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 }
15380 }
15381 if (obj1) {
15382 {
15383 arg2 = (int)(SWIG_As_int(obj1));
15384 if (SWIG_arg_fail(2)) SWIG_fail;
15385 }
15386 }
15387 if (obj2) {
15388 {
15389 arg3 = (int)(SWIG_As_int(obj2));
15390 if (SWIG_arg_fail(3)) SWIG_fail;
15391 }
15392 }
15393 if (obj3) {
15394 {
15395 arg4 = (int)(SWIG_As_int(obj3));
15396 if (SWIG_arg_fail(4)) SWIG_fail;
15397 }
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15416 int result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = SWIG_From_int((int)(result));
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj;
15443 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15444 int result;
15445 PyObject * obj0 = 0 ;
15446 char *kwnames[] = {
15447 (char *) "self", NULL
15448 };
15449
15450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15452 if (SWIG_arg_fail(1)) SWIG_fail;
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15456
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 {
15461 resultobj = SWIG_From_int((int)(result));
15462 }
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj;
15471 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15472 int arg2 ;
15473 PyObject * obj0 = 0 ;
15474 PyObject * obj1 = 0 ;
15475 char *kwnames[] = {
15476 (char *) "self",(char *) "orient", NULL
15477 };
15478
15479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 {
15483 arg2 = (int)(SWIG_As_int(obj1));
15484 if (SWIG_arg_fail(2)) SWIG_fail;
15485 }
15486 {
15487 PyThreadState* __tstate = wxPyBeginAllowThreads();
15488 (arg1)->SetOrientation(arg2);
15489
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 Py_INCREF(Py_None); resultobj = Py_None;
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15501 PyObject *resultobj;
15502 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15503 int arg2 ;
15504 PyObject * obj0 = 0 ;
15505 PyObject * obj1 = 0 ;
15506 char *kwnames[] = {
15507 (char *) "self",(char *) "pos", NULL
15508 };
15509
15510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15512 if (SWIG_arg_fail(1)) SWIG_fail;
15513 {
15514 arg2 = (int)(SWIG_As_int(obj1));
15515 if (SWIG_arg_fail(2)) SWIG_fail;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 (arg1)->SetPosition(arg2);
15520
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 Py_INCREF(Py_None); resultobj = Py_None;
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15532 PyObject *obj;
15533 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15534 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15535 Py_INCREF(obj);
15536 return Py_BuildValue((char *)"");
15537 }
15538 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj;
15540 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15541 int arg2 = (int) 0 ;
15542 int arg3 = (int) 0 ;
15543 wxScrollWinEvent *result;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 PyObject * obj2 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15552 if (obj0) {
15553 {
15554 arg1 = (wxEventType)(SWIG_As_int(obj0));
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 }
15557 }
15558 if (obj1) {
15559 {
15560 arg2 = (int)(SWIG_As_int(obj1));
15561 if (SWIG_arg_fail(2)) SWIG_fail;
15562 }
15563 }
15564 if (obj2) {
15565 {
15566 arg3 = (int)(SWIG_As_int(obj2));
15567 if (SWIG_arg_fail(3)) SWIG_fail;
15568 }
15569 }
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15578 return resultobj;
15579 fail:
15580 return NULL;
15581 }
15582
15583
15584 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15585 PyObject *resultobj;
15586 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15587 int result;
15588 PyObject * obj0 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "self", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15595 if (SWIG_arg_fail(1)) SWIG_fail;
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 {
15604 resultobj = SWIG_From_int((int)(result));
15605 }
15606 return resultobj;
15607 fail:
15608 return NULL;
15609 }
15610
15611
15612 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj;
15614 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15615 int result;
15616 PyObject * obj0 = 0 ;
15617 char *kwnames[] = {
15618 (char *) "self", NULL
15619 };
15620
15621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15623 if (SWIG_arg_fail(1)) SWIG_fail;
15624 {
15625 PyThreadState* __tstate = wxPyBeginAllowThreads();
15626 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15627
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 {
15632 resultobj = SWIG_From_int((int)(result));
15633 }
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15641 PyObject *resultobj;
15642 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15643 int arg2 ;
15644 PyObject * obj0 = 0 ;
15645 PyObject * obj1 = 0 ;
15646 char *kwnames[] = {
15647 (char *) "self",(char *) "orient", NULL
15648 };
15649
15650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15652 if (SWIG_arg_fail(1)) SWIG_fail;
15653 {
15654 arg2 = (int)(SWIG_As_int(obj1));
15655 if (SWIG_arg_fail(2)) SWIG_fail;
15656 }
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 (arg1)->SetOrientation(arg2);
15660
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 Py_INCREF(Py_None); resultobj = Py_None;
15665 return resultobj;
15666 fail:
15667 return NULL;
15668 }
15669
15670
15671 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15672 PyObject *resultobj;
15673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15674 int arg2 ;
15675 PyObject * obj0 = 0 ;
15676 PyObject * obj1 = 0 ;
15677 char *kwnames[] = {
15678 (char *) "self",(char *) "pos", NULL
15679 };
15680
15681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15683 if (SWIG_arg_fail(1)) SWIG_fail;
15684 {
15685 arg2 = (int)(SWIG_As_int(obj1));
15686 if (SWIG_arg_fail(2)) SWIG_fail;
15687 }
15688 {
15689 PyThreadState* __tstate = wxPyBeginAllowThreads();
15690 (arg1)->SetPosition(arg2);
15691
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 Py_INCREF(Py_None); resultobj = Py_None;
15696 return resultobj;
15697 fail:
15698 return NULL;
15699 }
15700
15701
15702 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15703 PyObject *obj;
15704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15705 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15706 Py_INCREF(obj);
15707 return Py_BuildValue((char *)"");
15708 }
15709 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15710 PyObject *resultobj;
15711 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15712 wxMouseEvent *result;
15713 PyObject * obj0 = 0 ;
15714 char *kwnames[] = {
15715 (char *) "mouseType", NULL
15716 };
15717
15718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15719 if (obj0) {
15720 {
15721 arg1 = (wxEventType)(SWIG_As_int(obj0));
15722 if (SWIG_arg_fail(1)) SWIG_fail;
15723 }
15724 }
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15728
15729 wxPyEndAllowThreads(__tstate);
15730 if (PyErr_Occurred()) SWIG_fail;
15731 }
15732 {
15733 resultobj = wxPyMake_wxObject(result, 1);
15734 }
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15742 PyObject *resultobj;
15743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15744 bool result;
15745 PyObject * obj0 = 0 ;
15746 char *kwnames[] = {
15747 (char *) "self", NULL
15748 };
15749
15750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15752 if (SWIG_arg_fail(1)) SWIG_fail;
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15756
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 {
15761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15762 }
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15770 PyObject *resultobj;
15771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15772 int arg2 = (int) wxMOUSE_BTN_ANY ;
15773 bool result;
15774 PyObject * obj0 = 0 ;
15775 PyObject * obj1 = 0 ;
15776 char *kwnames[] = {
15777 (char *) "self",(char *) "but", NULL
15778 };
15779
15780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15782 if (SWIG_arg_fail(1)) SWIG_fail;
15783 if (obj1) {
15784 {
15785 arg2 = (int)(SWIG_As_int(obj1));
15786 if (SWIG_arg_fail(2)) SWIG_fail;
15787 }
15788 }
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15792
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj;
15807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15808 int arg2 = (int) wxMOUSE_BTN_ANY ;
15809 bool result;
15810 PyObject * obj0 = 0 ;
15811 PyObject * obj1 = 0 ;
15812 char *kwnames[] = {
15813 (char *) "self",(char *) "but", NULL
15814 };
15815
15816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15818 if (SWIG_arg_fail(1)) SWIG_fail;
15819 if (obj1) {
15820 {
15821 arg2 = (int)(SWIG_As_int(obj1));
15822 if (SWIG_arg_fail(2)) SWIG_fail;
15823 }
15824 }
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15828
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 {
15833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15844 int arg2 = (int) wxMOUSE_BTN_ANY ;
15845 bool result;
15846 PyObject * obj0 = 0 ;
15847 PyObject * obj1 = 0 ;
15848 char *kwnames[] = {
15849 (char *) "self",(char *) "but", NULL
15850 };
15851
15852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15854 if (SWIG_arg_fail(1)) SWIG_fail;
15855 if (obj1) {
15856 {
15857 arg2 = (int)(SWIG_As_int(obj1));
15858 if (SWIG_arg_fail(2)) SWIG_fail;
15859 }
15860 }
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15864
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 {
15869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15870 }
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15878 PyObject *resultobj;
15879 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15880 int arg2 ;
15881 bool result;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self",(char *) "but", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 arg2 = (int)(SWIG_As_int(obj1));
15893 if (SWIG_arg_fail(2)) SWIG_fail;
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15898
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 {
15903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15904 }
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj;
15913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15914 int arg2 ;
15915 bool result;
15916 PyObject * obj0 = 0 ;
15917 PyObject * obj1 = 0 ;
15918 char *kwnames[] = {
15919 (char *) "self",(char *) "but", NULL
15920 };
15921
15922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15924 if (SWIG_arg_fail(1)) SWIG_fail;
15925 {
15926 arg2 = (int)(SWIG_As_int(obj1));
15927 if (SWIG_arg_fail(2)) SWIG_fail;
15928 }
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15932
15933 wxPyEndAllowThreads(__tstate);
15934 if (PyErr_Occurred()) SWIG_fail;
15935 }
15936 {
15937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15938 }
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj;
15947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15948 int result;
15949 PyObject * obj0 = 0 ;
15950 char *kwnames[] = {
15951 (char *) "self", NULL
15952 };
15953
15954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15960
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 {
15965 resultobj = SWIG_From_int((int)(result));
15966 }
15967 return resultobj;
15968 fail:
15969 return NULL;
15970 }
15971
15972
15973 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15974 PyObject *resultobj;
15975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15976 bool result;
15977 PyObject * obj0 = 0 ;
15978 char *kwnames[] = {
15979 (char *) "self", NULL
15980 };
15981
15982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15984 if (SWIG_arg_fail(1)) SWIG_fail;
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15988
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 {
15993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15994 }
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16004 bool result;
16005 PyObject * obj0 = 0 ;
16006 char *kwnames[] = {
16007 (char *) "self", NULL
16008 };
16009
16010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16012 if (SWIG_arg_fail(1)) SWIG_fail;
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16016
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 {
16021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16022 }
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16032 bool result;
16033 PyObject * obj0 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16058 PyObject *resultobj;
16059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16060 bool result;
16061 PyObject * obj0 = 0 ;
16062 char *kwnames[] = {
16063 (char *) "self", NULL
16064 };
16065
16066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16068 if (SWIG_arg_fail(1)) SWIG_fail;
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 {
16077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16078 }
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj;
16087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16088 bool result;
16089 PyObject * obj0 = 0 ;
16090 char *kwnames[] = {
16091 (char *) "self", NULL
16092 };
16093
16094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16096 if (SWIG_arg_fail(1)) SWIG_fail;
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16100
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 {
16105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16106 }
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16116 bool result;
16117 PyObject * obj0 = 0 ;
16118 char *kwnames[] = {
16119 (char *) "self", NULL
16120 };
16121
16122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16124 if (SWIG_arg_fail(1)) SWIG_fail;
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 {
16133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16134 }
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj;
16143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16144 bool result;
16145 PyObject * obj0 = 0 ;
16146 char *kwnames[] = {
16147 (char *) "self", NULL
16148 };
16149
16150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16152 if (SWIG_arg_fail(1)) SWIG_fail;
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16156
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj;
16171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16172 bool result;
16173 PyObject * obj0 = 0 ;
16174 char *kwnames[] = {
16175 (char *) "self", NULL
16176 };
16177
16178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16180 if (SWIG_arg_fail(1)) SWIG_fail;
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16184
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 {
16189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16190 }
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj;
16199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16200 bool result;
16201 PyObject * obj0 = 0 ;
16202 char *kwnames[] = {
16203 (char *) "self", NULL
16204 };
16205
16206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16208 if (SWIG_arg_fail(1)) SWIG_fail;
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 {
16217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16218 }
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16228 bool result;
16229 PyObject * obj0 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16240
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16256 bool result;
16257 PyObject * obj0 = 0 ;
16258 char *kwnames[] = {
16259 (char *) "self", NULL
16260 };
16261
16262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16264 if (SWIG_arg_fail(1)) SWIG_fail;
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16268
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj;
16283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16284 bool result;
16285 PyObject * obj0 = 0 ;
16286 char *kwnames[] = {
16287 (char *) "self", NULL
16288 };
16289
16290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16292 if (SWIG_arg_fail(1)) SWIG_fail;
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16296
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 {
16301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16302 }
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj;
16311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16312 bool result;
16313 PyObject * obj0 = 0 ;
16314 char *kwnames[] = {
16315 (char *) "self", NULL
16316 };
16317
16318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16320 if (SWIG_arg_fail(1)) SWIG_fail;
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16324
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 {
16329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16330 }
16331 return resultobj;
16332 fail:
16333 return NULL;
16334 }
16335
16336
16337 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16338 PyObject *resultobj;
16339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16340 bool result;
16341 PyObject * obj0 = 0 ;
16342 char *kwnames[] = {
16343 (char *) "self", NULL
16344 };
16345
16346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16348 if (SWIG_arg_fail(1)) SWIG_fail;
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 {
16357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16358 }
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16368 bool result;
16369 PyObject * obj0 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 result = (bool)(arg1)->LeftIsDown();
16380
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 {
16385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16386 }
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj;
16395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16396 bool result;
16397 PyObject * obj0 = 0 ;
16398 char *kwnames[] = {
16399 (char *) "self", NULL
16400 };
16401
16402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16404 if (SWIG_arg_fail(1)) SWIG_fail;
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 result = (bool)(arg1)->MiddleIsDown();
16408
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16424 bool result;
16425 PyObject * obj0 = 0 ;
16426 char *kwnames[] = {
16427 (char *) "self", NULL
16428 };
16429
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (bool)(arg1)->RightIsDown();
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 {
16441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16442 }
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj;
16451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16452 bool result;
16453 PyObject * obj0 = 0 ;
16454 char *kwnames[] = {
16455 (char *) "self", NULL
16456 };
16457
16458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16464
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16480 bool result;
16481 PyObject * obj0 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16498 }
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16508 bool result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16536 bool result;
16537 PyObject * obj0 = 0 ;
16538 char *kwnames[] = {
16539 (char *) "self", NULL
16540 };
16541
16542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16544 if (SWIG_arg_fail(1)) SWIG_fail;
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16548
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 {
16553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16554 }
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj;
16563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16564 wxPoint result;
16565 PyObject * obj0 = 0 ;
16566 char *kwnames[] = {
16567 (char *) "self", NULL
16568 };
16569
16570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16572 if (SWIG_arg_fail(1)) SWIG_fail;
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 result = (arg1)->GetPosition();
16576
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 wxPoint * resultptr;
16582 resultptr = new wxPoint((wxPoint &)(result));
16583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16584 }
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16594 long *arg2 = (long *) 0 ;
16595 long *arg3 = (long *) 0 ;
16596 long temp2 ;
16597 int res2 = 0 ;
16598 long temp3 ;
16599 int res3 = 0 ;
16600 PyObject * obj0 = 0 ;
16601 char *kwnames[] = {
16602 (char *) "self", NULL
16603 };
16604
16605 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16606 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16609 if (SWIG_arg_fail(1)) SWIG_fail;
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 (arg1)->GetPosition(arg2,arg3);
16613
16614 wxPyEndAllowThreads(__tstate);
16615 if (PyErr_Occurred()) SWIG_fail;
16616 }
16617 Py_INCREF(Py_None); resultobj = Py_None;
16618 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16619 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16620 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16621 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj;
16630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16631 wxDC *arg2 = 0 ;
16632 wxPoint result;
16633 PyObject * obj0 = 0 ;
16634 PyObject * obj1 = 0 ;
16635 char *kwnames[] = {
16636 (char *) "self",(char *) "dc", NULL
16637 };
16638
16639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16641 if (SWIG_arg_fail(1)) SWIG_fail;
16642 {
16643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(2)) SWIG_fail;
16645 if (arg2 == NULL) {
16646 SWIG_null_ref("wxDC");
16647 }
16648 if (SWIG_arg_fail(2)) SWIG_fail;
16649 }
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16653
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 {
16658 wxPoint * resultptr;
16659 resultptr = new wxPoint((wxPoint &)(result));
16660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16661 }
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16671 int result;
16672 PyObject * obj0 = 0 ;
16673 char *kwnames[] = {
16674 (char *) "self", NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16679 if (SWIG_arg_fail(1)) SWIG_fail;
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxMouseEvent const *)arg1)->GetX();
16683
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 {
16688 resultobj = SWIG_From_int((int)(result));
16689 }
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj;
16698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16699 int result;
16700 PyObject * obj0 = 0 ;
16701 char *kwnames[] = {
16702 (char *) "self", NULL
16703 };
16704
16705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxMouseEvent const *)arg1)->GetY();
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 {
16716 resultobj = SWIG_From_int((int)(result));
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16727 int result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16739
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = SWIG_From_int((int)(result));
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16755 int result;
16756 PyObject * obj0 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "self", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16763 if (SWIG_arg_fail(1)) SWIG_fail;
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 resultobj = SWIG_From_int((int)(result));
16773 }
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj;
16782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16783 int result;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 {
16800 resultobj = SWIG_From_int((int)(result));
16801 }
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj;
16810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16811 bool result;
16812 PyObject * obj0 = 0 ;
16813 char *kwnames[] = {
16814 (char *) "self", NULL
16815 };
16816
16817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16819 if (SWIG_arg_fail(1)) SWIG_fail;
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16823
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16829 }
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj;
16838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16839 int arg2 ;
16840 PyObject * obj0 = 0 ;
16841 PyObject * obj1 = 0 ;
16842 char *kwnames[] = {
16843 (char *) "self",(char *) "m_x", NULL
16844 };
16845
16846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16848 if (SWIG_arg_fail(1)) SWIG_fail;
16849 {
16850 arg2 = (int)(SWIG_As_int(obj1));
16851 if (SWIG_arg_fail(2)) SWIG_fail;
16852 }
16853 if (arg1) (arg1)->m_x = arg2;
16854
16855 Py_INCREF(Py_None); resultobj = Py_None;
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16865 int result;
16866 PyObject * obj0 = 0 ;
16867 char *kwnames[] = {
16868 (char *) "self", NULL
16869 };
16870
16871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16873 if (SWIG_arg_fail(1)) SWIG_fail;
16874 result = (int) ((arg1)->m_x);
16875
16876 {
16877 resultobj = SWIG_From_int((int)(result));
16878 }
16879 return resultobj;
16880 fail:
16881 return NULL;
16882 }
16883
16884
16885 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16886 PyObject *resultobj;
16887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16888 int arg2 ;
16889 PyObject * obj0 = 0 ;
16890 PyObject * obj1 = 0 ;
16891 char *kwnames[] = {
16892 (char *) "self",(char *) "m_y", NULL
16893 };
16894
16895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16897 if (SWIG_arg_fail(1)) SWIG_fail;
16898 {
16899 arg2 = (int)(SWIG_As_int(obj1));
16900 if (SWIG_arg_fail(2)) SWIG_fail;
16901 }
16902 if (arg1) (arg1)->m_y = arg2;
16903
16904 Py_INCREF(Py_None); resultobj = Py_None;
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj;
16913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16914 int result;
16915 PyObject * obj0 = 0 ;
16916 char *kwnames[] = {
16917 (char *) "self", NULL
16918 };
16919
16920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16922 if (SWIG_arg_fail(1)) SWIG_fail;
16923 result = (int) ((arg1)->m_y);
16924
16925 {
16926 resultobj = SWIG_From_int((int)(result));
16927 }
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj;
16936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16937 bool arg2 ;
16938 PyObject * obj0 = 0 ;
16939 PyObject * obj1 = 0 ;
16940 char *kwnames[] = {
16941 (char *) "self",(char *) "m_leftDown", NULL
16942 };
16943
16944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16946 if (SWIG_arg_fail(1)) SWIG_fail;
16947 {
16948 arg2 = (bool)(SWIG_As_bool(obj1));
16949 if (SWIG_arg_fail(2)) SWIG_fail;
16950 }
16951 if (arg1) (arg1)->m_leftDown = arg2;
16952
16953 Py_INCREF(Py_None); resultobj = Py_None;
16954 return resultobj;
16955 fail:
16956 return NULL;
16957 }
16958
16959
16960 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj;
16962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16963 bool result;
16964 PyObject * obj0 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 result = (bool) ((arg1)->m_leftDown);
16973
16974 {
16975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16976 }
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16986 bool arg2 ;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 char *kwnames[] = {
16990 (char *) "self",(char *) "m_middleDown", NULL
16991 };
16992
16993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16995 if (SWIG_arg_fail(1)) SWIG_fail;
16996 {
16997 arg2 = (bool)(SWIG_As_bool(obj1));
16998 if (SWIG_arg_fail(2)) SWIG_fail;
16999 }
17000 if (arg1) (arg1)->m_middleDown = arg2;
17001
17002 Py_INCREF(Py_None); resultobj = Py_None;
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj;
17011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17012 bool result;
17013 PyObject * obj0 = 0 ;
17014 char *kwnames[] = {
17015 (char *) "self", NULL
17016 };
17017
17018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17020 if (SWIG_arg_fail(1)) SWIG_fail;
17021 result = (bool) ((arg1)->m_middleDown);
17022
17023 {
17024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17025 }
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17035 bool arg2 ;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self",(char *) "m_rightDown", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 {
17046 arg2 = (bool)(SWIG_As_bool(obj1));
17047 if (SWIG_arg_fail(2)) SWIG_fail;
17048 }
17049 if (arg1) (arg1)->m_rightDown = arg2;
17050
17051 Py_INCREF(Py_None); resultobj = Py_None;
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj;
17060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17061 bool result;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 result = (bool) ((arg1)->m_rightDown);
17071
17072 {
17073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 bool arg2 ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self",(char *) "m_controlDown", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 arg2 = (bool)(SWIG_As_bool(obj1));
17096 if (SWIG_arg_fail(2)) SWIG_fail;
17097 }
17098 if (arg1) (arg1)->m_controlDown = arg2;
17099
17100 Py_INCREF(Py_None); resultobj = Py_None;
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17110 bool result;
17111 PyObject * obj0 = 0 ;
17112 char *kwnames[] = {
17113 (char *) "self", NULL
17114 };
17115
17116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(1)) SWIG_fail;
17119 result = (bool) ((arg1)->m_controlDown);
17120
17121 {
17122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17123 }
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj;
17132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17133 bool arg2 ;
17134 PyObject * obj0 = 0 ;
17135 PyObject * obj1 = 0 ;
17136 char *kwnames[] = {
17137 (char *) "self",(char *) "m_shiftDown", NULL
17138 };
17139
17140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17142 if (SWIG_arg_fail(1)) SWIG_fail;
17143 {
17144 arg2 = (bool)(SWIG_As_bool(obj1));
17145 if (SWIG_arg_fail(2)) SWIG_fail;
17146 }
17147 if (arg1) (arg1)->m_shiftDown = arg2;
17148
17149 Py_INCREF(Py_None); resultobj = Py_None;
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17159 bool result;
17160 PyObject * obj0 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 result = (bool) ((arg1)->m_shiftDown);
17169
17170 {
17171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17172 }
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17182 bool arg2 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "m_altDown", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 arg2 = (bool)(SWIG_As_bool(obj1));
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 }
17196 if (arg1) (arg1)->m_altDown = arg2;
17197
17198 Py_INCREF(Py_None); resultobj = Py_None;
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17208 bool result;
17209 PyObject * obj0 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 result = (bool) ((arg1)->m_altDown);
17218
17219 {
17220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17221 }
17222 return resultobj;
17223 fail:
17224 return NULL;
17225 }
17226
17227
17228 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17229 PyObject *resultobj;
17230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17231 bool arg2 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 char *kwnames[] = {
17235 (char *) "self",(char *) "m_metaDown", NULL
17236 };
17237
17238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17240 if (SWIG_arg_fail(1)) SWIG_fail;
17241 {
17242 arg2 = (bool)(SWIG_As_bool(obj1));
17243 if (SWIG_arg_fail(2)) SWIG_fail;
17244 }
17245 if (arg1) (arg1)->m_metaDown = arg2;
17246
17247 Py_INCREF(Py_None); resultobj = Py_None;
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 bool result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 result = (bool) ((arg1)->m_metaDown);
17267
17268 {
17269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17270 }
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17280 int arg2 ;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "self",(char *) "m_wheelRotation", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 {
17291 arg2 = (int)(SWIG_As_int(obj1));
17292 if (SWIG_arg_fail(2)) SWIG_fail;
17293 }
17294 if (arg1) (arg1)->m_wheelRotation = arg2;
17295
17296 Py_INCREF(Py_None); resultobj = Py_None;
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17304 PyObject *resultobj;
17305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17306 int result;
17307 PyObject * obj0 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 result = (int) ((arg1)->m_wheelRotation);
17316
17317 {
17318 resultobj = SWIG_From_int((int)(result));
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj;
17328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17329 int arg2 ;
17330 PyObject * obj0 = 0 ;
17331 PyObject * obj1 = 0 ;
17332 char *kwnames[] = {
17333 (char *) "self",(char *) "m_wheelDelta", NULL
17334 };
17335
17336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17338 if (SWIG_arg_fail(1)) SWIG_fail;
17339 {
17340 arg2 = (int)(SWIG_As_int(obj1));
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 }
17343 if (arg1) (arg1)->m_wheelDelta = arg2;
17344
17345 Py_INCREF(Py_None); resultobj = Py_None;
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj;
17354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17355 int result;
17356 PyObject * obj0 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 result = (int) ((arg1)->m_wheelDelta);
17365
17366 {
17367 resultobj = SWIG_From_int((int)(result));
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17378 int arg2 ;
17379 PyObject * obj0 = 0 ;
17380 PyObject * obj1 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self",(char *) "m_linesPerAction", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = (int)(SWIG_As_int(obj1));
17390 if (SWIG_arg_fail(2)) SWIG_fail;
17391 }
17392 if (arg1) (arg1)->m_linesPerAction = arg2;
17393
17394 Py_INCREF(Py_None); resultobj = Py_None;
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 result = (int) ((arg1)->m_linesPerAction);
17414
17415 {
17416 resultobj = SWIG_From_int((int)(result));
17417 }
17418 return resultobj;
17419 fail:
17420 return NULL;
17421 }
17422
17423
17424 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17425 PyObject *obj;
17426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17427 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17428 Py_INCREF(obj);
17429 return Py_BuildValue((char *)"");
17430 }
17431 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj;
17433 int arg1 = (int) 0 ;
17434 int arg2 = (int) 0 ;
17435 wxSetCursorEvent *result;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 char *kwnames[] = {
17439 (char *) "x",(char *) "y", NULL
17440 };
17441
17442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17443 if (obj0) {
17444 {
17445 arg1 = (int)(SWIG_As_int(obj0));
17446 if (SWIG_arg_fail(1)) SWIG_fail;
17447 }
17448 }
17449 if (obj1) {
17450 {
17451 arg2 = (int)(SWIG_As_int(obj1));
17452 if (SWIG_arg_fail(2)) SWIG_fail;
17453 }
17454 }
17455 {
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17458
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17470 PyObject *resultobj;
17471 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17472 int result;
17473 PyObject * obj0 = 0 ;
17474 char *kwnames[] = {
17475 (char *) "self", NULL
17476 };
17477
17478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17480 if (SWIG_arg_fail(1)) SWIG_fail;
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17484
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 {
17489 resultobj = SWIG_From_int((int)(result));
17490 }
17491 return resultobj;
17492 fail:
17493 return NULL;
17494 }
17495
17496
17497 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj;
17499 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17500 int result;
17501 PyObject * obj0 = 0 ;
17502 char *kwnames[] = {
17503 (char *) "self", NULL
17504 };
17505
17506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17508 if (SWIG_arg_fail(1)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17512
17513 wxPyEndAllowThreads(__tstate);
17514 if (PyErr_Occurred()) SWIG_fail;
17515 }
17516 {
17517 resultobj = SWIG_From_int((int)(result));
17518 }
17519 return resultobj;
17520 fail:
17521 return NULL;
17522 }
17523
17524
17525 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17526 PyObject *resultobj;
17527 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17528 wxCursor *arg2 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self",(char *) "cursor", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(2)) SWIG_fail;
17541 if (arg2 == NULL) {
17542 SWIG_null_ref("wxCursor");
17543 }
17544 if (SWIG_arg_fail(2)) SWIG_fail;
17545 }
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 (arg1)->SetCursor((wxCursor const &)*arg2);
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 Py_INCREF(Py_None); resultobj = Py_None;
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj;
17562 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17563 wxCursor *result;
17564 PyObject * obj0 = 0 ;
17565 char *kwnames[] = {
17566 (char *) "self", NULL
17567 };
17568
17569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17571 if (SWIG_arg_fail(1)) SWIG_fail;
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 {
17575 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17576 result = (wxCursor *) &_result_ref;
17577 }
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 wxCursor* resultptr = new wxCursor(*result);
17584 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17585 }
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17593 PyObject *resultobj;
17594 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17595 bool result;
17596 PyObject * obj0 = 0 ;
17597 char *kwnames[] = {
17598 (char *) "self", NULL
17599 };
17600
17601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17603 if (SWIG_arg_fail(1)) SWIG_fail;
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17607
17608 wxPyEndAllowThreads(__tstate);
17609 if (PyErr_Occurred()) SWIG_fail;
17610 }
17611 {
17612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17621 PyObject *obj;
17622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17623 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17624 Py_INCREF(obj);
17625 return Py_BuildValue((char *)"");
17626 }
17627 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17630 wxKeyEvent *result;
17631 PyObject * obj0 = 0 ;
17632 char *kwnames[] = {
17633 (char *) "keyType", NULL
17634 };
17635
17636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17637 if (obj0) {
17638 {
17639 arg1 = (wxEventType)(SWIG_As_int(obj0));
17640 if (SWIG_arg_fail(1)) SWIG_fail;
17641 }
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17646
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17651 return resultobj;
17652 fail:
17653 return NULL;
17654 }
17655
17656
17657 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17658 PyObject *resultobj;
17659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17660 bool result;
17661 PyObject * obj0 = 0 ;
17662 char *kwnames[] = {
17663 (char *) "self", NULL
17664 };
17665
17666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17668 if (SWIG_arg_fail(1)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17672
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 {
17677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17678 }
17679 return resultobj;
17680 fail:
17681 return NULL;
17682 }
17683
17684
17685 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17688 bool result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 PyThreadState* __tstate = wxPyBeginAllowThreads();
17699 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17700
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 {
17705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17706 }
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17714 PyObject *resultobj;
17715 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17716 bool result;
17717 PyObject * obj0 = 0 ;
17718 char *kwnames[] = {
17719 (char *) "self", NULL
17720 };
17721
17722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17724 if (SWIG_arg_fail(1)) SWIG_fail;
17725 {
17726 PyThreadState* __tstate = wxPyBeginAllowThreads();
17727 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17728
17729 wxPyEndAllowThreads(__tstate);
17730 if (PyErr_Occurred()) SWIG_fail;
17731 }
17732 {
17733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17734 }
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj;
17743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17744 bool result;
17745 PyObject * obj0 = 0 ;
17746 char *kwnames[] = {
17747 (char *) "self", NULL
17748 };
17749
17750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17752 if (SWIG_arg_fail(1)) SWIG_fail;
17753 {
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17756
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17772 bool result;
17773 PyObject * obj0 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17784
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 {
17789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj;
17799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17800 bool result;
17801 PyObject * obj0 = 0 ;
17802 char *kwnames[] = {
17803 (char *) "self", NULL
17804 };
17805
17806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(1)) SWIG_fail;
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17812
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17818 }
17819 return resultobj;
17820 fail:
17821 return NULL;
17822 }
17823
17824
17825 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17826 PyObject *resultobj;
17827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17828 int result;
17829 PyObject * obj0 = 0 ;
17830 char *kwnames[] = {
17831 (char *) "self", NULL
17832 };
17833
17834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17836 if (SWIG_arg_fail(1)) SWIG_fail;
17837 {
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17840
17841 wxPyEndAllowThreads(__tstate);
17842 if (PyErr_Occurred()) SWIG_fail;
17843 }
17844 {
17845 resultobj = SWIG_From_int((int)(result));
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj;
17855 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17856 int result;
17857 PyObject * obj0 = 0 ;
17858 char *kwnames[] = {
17859 (char *) "self", NULL
17860 };
17861
17862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17864 if (SWIG_arg_fail(1)) SWIG_fail;
17865 {
17866 PyThreadState* __tstate = wxPyBeginAllowThreads();
17867 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17868
17869 wxPyEndAllowThreads(__tstate);
17870 if (PyErr_Occurred()) SWIG_fail;
17871 }
17872 {
17873 resultobj = SWIG_From_int((int)(result));
17874 }
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17884 unsigned int result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "self", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17892 if (SWIG_arg_fail(1)) SWIG_fail;
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17896
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17902 }
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj;
17911 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17912 unsigned int result;
17913 PyObject * obj0 = 0 ;
17914 char *kwnames[] = {
17915 (char *) "self", NULL
17916 };
17917
17918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17940 wxPoint result;
17941 PyObject * obj0 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "self", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17948 if (SWIG_arg_fail(1)) SWIG_fail;
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (arg1)->GetPosition();
17952
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 wxPoint * resultptr;
17958 resultptr = new wxPoint((wxPoint &)(result));
17959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17968 PyObject *resultobj;
17969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17970 long *arg2 = (long *) 0 ;
17971 long *arg3 = (long *) 0 ;
17972 long temp2 ;
17973 int res2 = 0 ;
17974 long temp3 ;
17975 int res3 = 0 ;
17976 PyObject * obj0 = 0 ;
17977 char *kwnames[] = {
17978 (char *) "self", NULL
17979 };
17980
17981 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17982 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 (arg1)->GetPosition(arg2,arg3);
17989
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 Py_INCREF(Py_None); resultobj = Py_None;
17994 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17995 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17996 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17997 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj;
18006 wxKeyEvent *arg1 = (wxKeyEvent *) 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:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18015 if (SWIG_arg_fail(1)) SWIG_fail;
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (int)((wxKeyEvent const *)arg1)->GetX();
18019
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = SWIG_From_int((int)(result));
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj;
18034 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18035 int result;
18036 PyObject * obj0 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 result = (int)((wxKeyEvent const *)arg1)->GetY();
18047
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = SWIG_From_int((int)(result));
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj;
18062 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18063 int arg2 ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 char *kwnames[] = {
18067 (char *) "self",(char *) "m_x", NULL
18068 };
18069
18070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18072 if (SWIG_arg_fail(1)) SWIG_fail;
18073 {
18074 arg2 = (int)(SWIG_As_int(obj1));
18075 if (SWIG_arg_fail(2)) SWIG_fail;
18076 }
18077 if (arg1) (arg1)->m_x = arg2;
18078
18079 Py_INCREF(Py_None); resultobj = Py_None;
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj;
18088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18089 int result;
18090 PyObject * obj0 = 0 ;
18091 char *kwnames[] = {
18092 (char *) "self", NULL
18093 };
18094
18095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18097 if (SWIG_arg_fail(1)) SWIG_fail;
18098 result = (int) ((arg1)->m_x);
18099
18100 {
18101 resultobj = SWIG_From_int((int)(result));
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj;
18111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18112 int arg2 ;
18113 PyObject * obj0 = 0 ;
18114 PyObject * obj1 = 0 ;
18115 char *kwnames[] = {
18116 (char *) "self",(char *) "m_y", NULL
18117 };
18118
18119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18121 if (SWIG_arg_fail(1)) SWIG_fail;
18122 {
18123 arg2 = (int)(SWIG_As_int(obj1));
18124 if (SWIG_arg_fail(2)) SWIG_fail;
18125 }
18126 if (arg1) (arg1)->m_y = arg2;
18127
18128 Py_INCREF(Py_None); resultobj = Py_None;
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj;
18137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18138 int result;
18139 PyObject * obj0 = 0 ;
18140 char *kwnames[] = {
18141 (char *) "self", NULL
18142 };
18143
18144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(1)) SWIG_fail;
18147 result = (int) ((arg1)->m_y);
18148
18149 {
18150 resultobj = SWIG_From_int((int)(result));
18151 }
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj;
18160 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18161 long arg2 ;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self",(char *) "m_keyCode", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 {
18172 arg2 = (long)(SWIG_As_long(obj1));
18173 if (SWIG_arg_fail(2)) SWIG_fail;
18174 }
18175 if (arg1) (arg1)->m_keyCode = arg2;
18176
18177 Py_INCREF(Py_None); resultobj = Py_None;
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj;
18186 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18187 long result;
18188 PyObject * obj0 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 result = (long) ((arg1)->m_keyCode);
18197
18198 {
18199 resultobj = SWIG_From_long((long)(result));
18200 }
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18210 bool arg2 ;
18211 PyObject * obj0 = 0 ;
18212 PyObject * obj1 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "self",(char *) "m_controlDown", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 {
18221 arg2 = (bool)(SWIG_As_bool(obj1));
18222 if (SWIG_arg_fail(2)) SWIG_fail;
18223 }
18224 if (arg1) (arg1)->m_controlDown = arg2;
18225
18226 Py_INCREF(Py_None); resultobj = Py_None;
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18236 bool result;
18237 PyObject * obj0 = 0 ;
18238 char *kwnames[] = {
18239 (char *) "self", NULL
18240 };
18241
18242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 result = (bool) ((arg1)->m_controlDown);
18246
18247 {
18248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18249 }
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18259 bool arg2 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char *kwnames[] = {
18263 (char *) "self",(char *) "m_shiftDown", NULL
18264 };
18265
18266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18268 if (SWIG_arg_fail(1)) SWIG_fail;
18269 {
18270 arg2 = (bool)(SWIG_As_bool(obj1));
18271 if (SWIG_arg_fail(2)) SWIG_fail;
18272 }
18273 if (arg1) (arg1)->m_shiftDown = arg2;
18274
18275 Py_INCREF(Py_None); resultobj = Py_None;
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18285 bool result;
18286 PyObject * obj0 = 0 ;
18287 char *kwnames[] = {
18288 (char *) "self", NULL
18289 };
18290
18291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18293 if (SWIG_arg_fail(1)) SWIG_fail;
18294 result = (bool) ((arg1)->m_shiftDown);
18295
18296 {
18297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18308 bool arg2 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "m_altDown", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 arg2 = (bool)(SWIG_As_bool(obj1));
18320 if (SWIG_arg_fail(2)) SWIG_fail;
18321 }
18322 if (arg1) (arg1)->m_altDown = arg2;
18323
18324 Py_INCREF(Py_None); resultobj = Py_None;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18334 bool result;
18335 PyObject * obj0 = 0 ;
18336 char *kwnames[] = {
18337 (char *) "self", NULL
18338 };
18339
18340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18342 if (SWIG_arg_fail(1)) SWIG_fail;
18343 result = (bool) ((arg1)->m_altDown);
18344
18345 {
18346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj;
18356 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18357 bool arg2 ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self",(char *) "m_metaDown", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 arg2 = (bool)(SWIG_As_bool(obj1));
18369 if (SWIG_arg_fail(2)) SWIG_fail;
18370 }
18371 if (arg1) (arg1)->m_metaDown = arg2;
18372
18373 Py_INCREF(Py_None); resultobj = Py_None;
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18383 bool result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 result = (bool) ((arg1)->m_metaDown);
18393
18394 {
18395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18396 }
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18406 bool arg2 ;
18407 PyObject * obj0 = 0 ;
18408 PyObject * obj1 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "self",(char *) "m_scanCode", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18415 if (SWIG_arg_fail(1)) SWIG_fail;
18416 {
18417 arg2 = (bool)(SWIG_As_bool(obj1));
18418 if (SWIG_arg_fail(2)) SWIG_fail;
18419 }
18420 if (arg1) (arg1)->m_scanCode = arg2;
18421
18422 Py_INCREF(Py_None); resultobj = Py_None;
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 result = (bool) ((arg1)->m_scanCode);
18442
18443 {
18444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18445 }
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj;
18454 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18455 unsigned int arg2 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self",(char *) "m_rawCode", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18467 if (SWIG_arg_fail(2)) SWIG_fail;
18468 }
18469 if (arg1) (arg1)->m_rawCode = arg2;
18470
18471 Py_INCREF(Py_None); resultobj = Py_None;
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18481 unsigned int result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 result = (unsigned int) ((arg1)->m_rawCode);
18491
18492 {
18493 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18504 unsigned int arg2 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self",(char *) "m_rawFlags", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18516 if (SWIG_arg_fail(2)) SWIG_fail;
18517 }
18518 if (arg1) (arg1)->m_rawFlags = arg2;
18519
18520 Py_INCREF(Py_None); resultobj = Py_None;
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18530 unsigned int result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 result = (unsigned int) ((arg1)->m_rawFlags);
18540
18541 {
18542 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18543 }
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18551 PyObject *obj;
18552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18553 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18554 Py_INCREF(obj);
18555 return Py_BuildValue((char *)"");
18556 }
18557 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj;
18559 wxSize const &arg1_defvalue = wxDefaultSize ;
18560 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18561 int arg2 = (int) 0 ;
18562 wxSizeEvent *result;
18563 wxSize temp1 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "sz",(char *) "winid", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18571 if (obj0) {
18572 {
18573 arg1 = &temp1;
18574 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18575 }
18576 }
18577 if (obj1) {
18578 {
18579 arg2 = (int)(SWIG_As_int(obj1));
18580 if (SWIG_arg_fail(2)) SWIG_fail;
18581 }
18582 }
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18586
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18600 wxSize result;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = ((wxSizeEvent const *)arg1)->GetSize();
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 {
18617 wxSize * resultptr;
18618 resultptr = new wxSize((wxSize &)(result));
18619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18620 }
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18628 PyObject *resultobj;
18629 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18630 wxRect result;
18631 PyObject * obj0 = 0 ;
18632 char *kwnames[] = {
18633 (char *) "self", NULL
18634 };
18635
18636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18638 if (SWIG_arg_fail(1)) SWIG_fail;
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = ((wxSizeEvent const *)arg1)->GetRect();
18642
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 {
18647 wxRect * resultptr;
18648 resultptr = new wxRect((wxRect &)(result));
18649 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18650 }
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18660 wxRect arg2 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "rect", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 wxRect * argp;
18672 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18673 if (SWIG_arg_fail(2)) SWIG_fail;
18674 if (argp == NULL) {
18675 SWIG_null_ref("wxRect");
18676 }
18677 if (SWIG_arg_fail(2)) SWIG_fail;
18678 arg2 = *argp;
18679 }
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 (arg1)->SetRect(arg2);
18683
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 Py_INCREF(Py_None); resultobj = Py_None;
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj;
18696 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18697 wxSize arg2 ;
18698 PyObject * obj0 = 0 ;
18699 PyObject * obj1 = 0 ;
18700 char *kwnames[] = {
18701 (char *) "self",(char *) "size", NULL
18702 };
18703
18704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18706 if (SWIG_arg_fail(1)) SWIG_fail;
18707 {
18708 wxSize * argp;
18709 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18710 if (SWIG_arg_fail(2)) SWIG_fail;
18711 if (argp == NULL) {
18712 SWIG_null_ref("wxSize");
18713 }
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 arg2 = *argp;
18716 }
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 wxSizeEvent_SetSize(arg1,arg2);
18720
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 Py_INCREF(Py_None); resultobj = Py_None;
18725 return resultobj;
18726 fail:
18727 return NULL;
18728 }
18729
18730
18731 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj;
18733 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18734 wxSize *arg2 = (wxSize *) 0 ;
18735 PyObject * obj0 = 0 ;
18736 PyObject * obj1 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "self",(char *) "m_size", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(2)) SWIG_fail;
18746 if (arg1) (arg1)->m_size = *arg2;
18747
18748 Py_INCREF(Py_None); resultobj = Py_None;
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18758 wxSize *result;
18759 PyObject * obj0 = 0 ;
18760 char *kwnames[] = {
18761 (char *) "self", NULL
18762 };
18763
18764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18766 if (SWIG_arg_fail(1)) SWIG_fail;
18767 result = (wxSize *)& ((arg1)->m_size);
18768
18769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj;
18778 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18779 wxRect *arg2 = (wxRect *) 0 ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 char *kwnames[] = {
18783 (char *) "self",(char *) "m_rect", NULL
18784 };
18785
18786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18788 if (SWIG_arg_fail(1)) SWIG_fail;
18789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(2)) SWIG_fail;
18791 if (arg1) (arg1)->m_rect = *arg2;
18792
18793 Py_INCREF(Py_None); resultobj = Py_None;
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj;
18802 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18803 wxRect *result;
18804 PyObject * obj0 = 0 ;
18805 char *kwnames[] = {
18806 (char *) "self", NULL
18807 };
18808
18809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18811 if (SWIG_arg_fail(1)) SWIG_fail;
18812 result = (wxRect *)& ((arg1)->m_rect);
18813
18814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18822 PyObject *obj;
18823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18824 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18825 Py_INCREF(obj);
18826 return Py_BuildValue((char *)"");
18827 }
18828 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18829 PyObject *resultobj;
18830 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18831 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18832 int arg2 = (int) 0 ;
18833 wxMoveEvent *result;
18834 wxPoint temp1 ;
18835 PyObject * obj0 = 0 ;
18836 PyObject * obj1 = 0 ;
18837 char *kwnames[] = {
18838 (char *) "pos",(char *) "winid", NULL
18839 };
18840
18841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18842 if (obj0) {
18843 {
18844 arg1 = &temp1;
18845 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18846 }
18847 }
18848 if (obj1) {
18849 {
18850 arg2 = (int)(SWIG_As_int(obj1));
18851 if (SWIG_arg_fail(2)) SWIG_fail;
18852 }
18853 }
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18857
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj;
18870 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18871 wxPoint result;
18872 PyObject * obj0 = 0 ;
18873 char *kwnames[] = {
18874 (char *) "self", NULL
18875 };
18876
18877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18879 if (SWIG_arg_fail(1)) SWIG_fail;
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 result = ((wxMoveEvent const *)arg1)->GetPosition();
18883
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 {
18888 wxPoint * resultptr;
18889 resultptr = new wxPoint((wxPoint &)(result));
18890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18891 }
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj;
18900 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18901 wxRect result;
18902 PyObject * obj0 = 0 ;
18903 char *kwnames[] = {
18904 (char *) "self", NULL
18905 };
18906
18907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18909 if (SWIG_arg_fail(1)) SWIG_fail;
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = ((wxMoveEvent const *)arg1)->GetRect();
18913
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 {
18918 wxRect * resultptr;
18919 resultptr = new wxRect((wxRect &)(result));
18920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18921 }
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj;
18930 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18931 wxRect arg2 ;
18932 PyObject * obj0 = 0 ;
18933 PyObject * obj1 = 0 ;
18934 char *kwnames[] = {
18935 (char *) "self",(char *) "rect", NULL
18936 };
18937
18938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18940 if (SWIG_arg_fail(1)) SWIG_fail;
18941 {
18942 wxRect * argp;
18943 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18944 if (SWIG_arg_fail(2)) SWIG_fail;
18945 if (argp == NULL) {
18946 SWIG_null_ref("wxRect");
18947 }
18948 if (SWIG_arg_fail(2)) SWIG_fail;
18949 arg2 = *argp;
18950 }
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 (arg1)->SetRect(arg2);
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 Py_INCREF(Py_None); resultobj = Py_None;
18959 return resultobj;
18960 fail:
18961 return NULL;
18962 }
18963
18964
18965 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18966 PyObject *resultobj;
18967 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18968 wxPoint arg2 ;
18969 PyObject * obj0 = 0 ;
18970 PyObject * obj1 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self",(char *) "pos", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 wxPoint * argp;
18980 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
18981 if (SWIG_arg_fail(2)) SWIG_fail;
18982 if (argp == NULL) {
18983 SWIG_null_ref("wxPoint");
18984 }
18985 if (SWIG_arg_fail(2)) SWIG_fail;
18986 arg2 = *argp;
18987 }
18988 {
18989 PyThreadState* __tstate = wxPyBeginAllowThreads();
18990 wxMoveEvent_SetPosition(arg1,arg2);
18991
18992 wxPyEndAllowThreads(__tstate);
18993 if (PyErr_Occurred()) SWIG_fail;
18994 }
18995 Py_INCREF(Py_None); resultobj = Py_None;
18996 return resultobj;
18997 fail:
18998 return NULL;
18999 }
19000
19001
19002 static PyObject *_wrap_MoveEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
19003 PyObject *resultobj;
19004 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19005 wxPoint *arg2 = (wxPoint *) 0 ;
19006 PyObject * obj0 = 0 ;
19007 PyObject * obj1 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "self",(char *) "m_pos", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
19013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19014 if (SWIG_arg_fail(1)) SWIG_fail;
19015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
19016 if (SWIG_arg_fail(2)) SWIG_fail;
19017 if (arg1) (arg1)->m_pos = *arg2;
19018
19019 Py_INCREF(Py_None); resultobj = Py_None;
19020 return resultobj;
19021 fail:
19022 return NULL;
19023 }
19024
19025
19026 static PyObject *_wrap_MoveEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj;
19028 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19029 wxPoint *result;
19030 PyObject * obj0 = 0 ;
19031 char *kwnames[] = {
19032 (char *) "self", NULL
19033 };
19034
19035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_pos_get",kwnames,&obj0)) goto fail;
19036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19037 if (SWIG_arg_fail(1)) SWIG_fail;
19038 result = (wxPoint *)& ((arg1)->m_pos);
19039
19040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
19041 return resultobj;
19042 fail:
19043 return NULL;
19044 }
19045
19046
19047 static PyObject *_wrap_MoveEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19048 PyObject *resultobj;
19049 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19050 wxRect *arg2 = (wxRect *) 0 ;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 char *kwnames[] = {
19054 (char *) "self",(char *) "m_rect", NULL
19055 };
19056
19057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19059 if (SWIG_arg_fail(1)) SWIG_fail;
19060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(2)) SWIG_fail;
19062 if (arg1) (arg1)->m_rect = *arg2;
19063
19064 Py_INCREF(Py_None); resultobj = Py_None;
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_MoveEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19074 wxRect *result;
19075 PyObject * obj0 = 0 ;
19076 char *kwnames[] = {
19077 (char *) "self", NULL
19078 };
19079
19080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_rect_get",kwnames,&obj0)) goto fail;
19081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 result = (wxRect *)& ((arg1)->m_rect);
19084
19085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19086 return resultobj;
19087 fail:
19088 return NULL;
19089 }
19090
19091
19092 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19093 PyObject *obj;
19094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19095 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19096 Py_INCREF(obj);
19097 return Py_BuildValue((char *)"");
19098 }
19099 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19100 PyObject *resultobj;
19101 int arg1 = (int) 0 ;
19102 wxPaintEvent *result;
19103 PyObject * obj0 = 0 ;
19104 char *kwnames[] = {
19105 (char *) "Id", NULL
19106 };
19107
19108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19109 if (obj0) {
19110 {
19111 arg1 = (int)(SWIG_As_int(obj0));
19112 if (SWIG_arg_fail(1)) SWIG_fail;
19113 }
19114 }
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19118
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19130 PyObject *obj;
19131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19132 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19133 Py_INCREF(obj);
19134 return Py_BuildValue((char *)"");
19135 }
19136 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 int arg1 = (int) 0 ;
19139 wxNcPaintEvent *result;
19140 PyObject * obj0 = 0 ;
19141 char *kwnames[] = {
19142 (char *) "winid", NULL
19143 };
19144
19145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19146 if (obj0) {
19147 {
19148 arg1 = (int)(SWIG_As_int(obj0));
19149 if (SWIG_arg_fail(1)) SWIG_fail;
19150 }
19151 }
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19167 PyObject *obj;
19168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19169 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19170 Py_INCREF(obj);
19171 return Py_BuildValue((char *)"");
19172 }
19173 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj;
19175 int arg1 = (int) 0 ;
19176 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19177 wxEraseEvent *result;
19178 PyObject * obj0 = 0 ;
19179 PyObject * obj1 = 0 ;
19180 char *kwnames[] = {
19181 (char *) "Id",(char *) "dc", NULL
19182 };
19183
19184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19185 if (obj0) {
19186 {
19187 arg1 = (int)(SWIG_As_int(obj0));
19188 if (SWIG_arg_fail(1)) SWIG_fail;
19189 }
19190 }
19191 if (obj1) {
19192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(2)) SWIG_fail;
19194 }
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19212 wxDC *result;
19213 PyObject * obj0 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "self", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19220 if (SWIG_arg_fail(1)) SWIG_fail;
19221 {
19222 PyThreadState* __tstate = wxPyBeginAllowThreads();
19223 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19224
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 {
19229 resultobj = wxPyMake_wxObject(result, 0);
19230 }
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19238 PyObject *obj;
19239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19240 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19241 Py_INCREF(obj);
19242 return Py_BuildValue((char *)"");
19243 }
19244 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj;
19246 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19247 int arg2 = (int) 0 ;
19248 wxFocusEvent *result;
19249 PyObject * obj0 = 0 ;
19250 PyObject * obj1 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "type",(char *) "winid", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19256 if (obj0) {
19257 {
19258 arg1 = (wxEventType)(SWIG_As_int(obj0));
19259 if (SWIG_arg_fail(1)) SWIG_fail;
19260 }
19261 }
19262 if (obj1) {
19263 {
19264 arg2 = (int)(SWIG_As_int(obj1));
19265 if (SWIG_arg_fail(2)) SWIG_fail;
19266 }
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19283 PyObject *resultobj;
19284 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19285 wxWindow *result;
19286 PyObject * obj0 = 0 ;
19287 char *kwnames[] = {
19288 (char *) "self", NULL
19289 };
19290
19291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19293 if (SWIG_arg_fail(1)) SWIG_fail;
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19297
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = wxPyMake_wxObject(result, 0);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj;
19312 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19313 wxWindow *arg2 = (wxWindow *) 0 ;
19314 PyObject * obj0 = 0 ;
19315 PyObject * obj1 = 0 ;
19316 char *kwnames[] = {
19317 (char *) "self",(char *) "win", NULL
19318 };
19319
19320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19322 if (SWIG_arg_fail(1)) SWIG_fail;
19323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19324 if (SWIG_arg_fail(2)) SWIG_fail;
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 (arg1)->SetWindow(arg2);
19328
19329 wxPyEndAllowThreads(__tstate);
19330 if (PyErr_Occurred()) SWIG_fail;
19331 }
19332 Py_INCREF(Py_None); resultobj = Py_None;
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19340 PyObject *obj;
19341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19342 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19343 Py_INCREF(obj);
19344 return Py_BuildValue((char *)"");
19345 }
19346 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19347 PyObject *resultobj;
19348 wxWindow *arg1 = (wxWindow *) NULL ;
19349 wxChildFocusEvent *result;
19350 PyObject * obj0 = 0 ;
19351 char *kwnames[] = {
19352 (char *) "win", NULL
19353 };
19354
19355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19356 if (obj0) {
19357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(1)) SWIG_fail;
19359 }
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19363
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj;
19376 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19377 wxWindow *result;
19378 PyObject * obj0 = 0 ;
19379 char *kwnames[] = {
19380 (char *) "self", NULL
19381 };
19382
19383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19385 if (SWIG_arg_fail(1)) SWIG_fail;
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 {
19394 resultobj = wxPyMake_wxObject(result, 0);
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19403 PyObject *obj;
19404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19405 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19406 Py_INCREF(obj);
19407 return Py_BuildValue((char *)"");
19408 }
19409 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj;
19411 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19412 bool arg2 = (bool) true ;
19413 int arg3 = (int) 0 ;
19414 wxActivateEvent *result;
19415 PyObject * obj0 = 0 ;
19416 PyObject * obj1 = 0 ;
19417 PyObject * obj2 = 0 ;
19418 char *kwnames[] = {
19419 (char *) "type",(char *) "active",(char *) "Id", NULL
19420 };
19421
19422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19423 if (obj0) {
19424 {
19425 arg1 = (wxEventType)(SWIG_As_int(obj0));
19426 if (SWIG_arg_fail(1)) SWIG_fail;
19427 }
19428 }
19429 if (obj1) {
19430 {
19431 arg2 = (bool)(SWIG_As_bool(obj1));
19432 if (SWIG_arg_fail(2)) SWIG_fail;
19433 }
19434 }
19435 if (obj2) {
19436 {
19437 arg3 = (int)(SWIG_As_int(obj2));
19438 if (SWIG_arg_fail(3)) SWIG_fail;
19439 }
19440 }
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19444
19445 wxPyEndAllowThreads(__tstate);
19446 if (PyErr_Occurred()) SWIG_fail;
19447 }
19448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19456 PyObject *resultobj;
19457 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19458 bool result;
19459 PyObject * obj0 = 0 ;
19460 char *kwnames[] = {
19461 (char *) "self", NULL
19462 };
19463
19464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19466 if (SWIG_arg_fail(1)) SWIG_fail;
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19470
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 {
19475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19476 }
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19484 PyObject *obj;
19485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19486 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19487 Py_INCREF(obj);
19488 return Py_BuildValue((char *)"");
19489 }
19490 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19491 PyObject *resultobj;
19492 int arg1 = (int) 0 ;
19493 wxInitDialogEvent *result;
19494 PyObject * obj0 = 0 ;
19495 char *kwnames[] = {
19496 (char *) "Id", NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19500 if (obj0) {
19501 {
19502 arg1 = (int)(SWIG_As_int(obj0));
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 }
19505 }
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19509
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19521 PyObject *obj;
19522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19523 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19524 Py_INCREF(obj);
19525 return Py_BuildValue((char *)"");
19526 }
19527 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj;
19529 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19530 int arg2 = (int) 0 ;
19531 wxMenu *arg3 = (wxMenu *) NULL ;
19532 wxMenuEvent *result;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "type",(char *) "winid",(char *) "menu", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19541 if (obj0) {
19542 {
19543 arg1 = (wxEventType)(SWIG_As_int(obj0));
19544 if (SWIG_arg_fail(1)) SWIG_fail;
19545 }
19546 }
19547 if (obj1) {
19548 {
19549 arg2 = (int)(SWIG_As_int(obj1));
19550 if (SWIG_arg_fail(2)) SWIG_fail;
19551 }
19552 }
19553 if (obj2) {
19554 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19555 if (SWIG_arg_fail(3)) SWIG_fail;
19556 }
19557 {
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19560
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj;
19573 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19574 int result;
19575 PyObject * obj0 = 0 ;
19576 char *kwnames[] = {
19577 (char *) "self", NULL
19578 };
19579
19580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19582 if (SWIG_arg_fail(1)) SWIG_fail;
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19586
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 {
19591 resultobj = SWIG_From_int((int)(result));
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19602 bool result;
19603 PyObject * obj0 = 0 ;
19604 char *kwnames[] = {
19605 (char *) "self", NULL
19606 };
19607
19608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19610 if (SWIG_arg_fail(1)) SWIG_fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19614
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 {
19619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj;
19629 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19630 wxMenu *result;
19631 PyObject * obj0 = 0 ;
19632 char *kwnames[] = {
19633 (char *) "self", NULL
19634 };
19635
19636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19638 if (SWIG_arg_fail(1)) SWIG_fail;
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19642
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 {
19647 resultobj = wxPyMake_wxObject(result, 0);
19648 }
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19656 PyObject *obj;
19657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19658 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19659 Py_INCREF(obj);
19660 return Py_BuildValue((char *)"");
19661 }
19662 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19665 int arg2 = (int) 0 ;
19666 wxCloseEvent *result;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "type",(char *) "winid", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19674 if (obj0) {
19675 {
19676 arg1 = (wxEventType)(SWIG_As_int(obj0));
19677 if (SWIG_arg_fail(1)) SWIG_fail;
19678 }
19679 }
19680 if (obj1) {
19681 {
19682 arg2 = (int)(SWIG_As_int(obj1));
19683 if (SWIG_arg_fail(2)) SWIG_fail;
19684 }
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19703 bool arg2 ;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 char *kwnames[] = {
19707 (char *) "self",(char *) "logOff", NULL
19708 };
19709
19710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19712 if (SWIG_arg_fail(1)) SWIG_fail;
19713 {
19714 arg2 = (bool)(SWIG_As_bool(obj1));
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 }
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 (arg1)->SetLoggingOff(arg2);
19720
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 Py_INCREF(Py_None); resultobj = Py_None;
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj;
19733 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19734 bool result;
19735 PyObject * obj0 = 0 ;
19736 char *kwnames[] = {
19737 (char *) "self", NULL
19738 };
19739
19740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19742 if (SWIG_arg_fail(1)) SWIG_fail;
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19746
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 {
19751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19752 }
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj;
19761 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19762 bool arg2 = (bool) true ;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self",(char *) "veto", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 if (obj1) {
19773 {
19774 arg2 = (bool)(SWIG_As_bool(obj1));
19775 if (SWIG_arg_fail(2)) SWIG_fail;
19776 }
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 (arg1)->Veto(arg2);
19781
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 Py_INCREF(Py_None); resultobj = Py_None;
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19793 PyObject *resultobj;
19794 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19795 bool arg2 ;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 char *kwnames[] = {
19799 (char *) "self",(char *) "canVeto", NULL
19800 };
19801
19802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19804 if (SWIG_arg_fail(1)) SWIG_fail;
19805 {
19806 arg2 = (bool)(SWIG_As_bool(obj1));
19807 if (SWIG_arg_fail(2)) SWIG_fail;
19808 }
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetCanVeto(arg2);
19812
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 Py_INCREF(Py_None); resultobj = Py_None;
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj;
19825 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19826 bool result;
19827 PyObject * obj0 = 0 ;
19828 char *kwnames[] = {
19829 (char *) "self", NULL
19830 };
19831
19832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19834 if (SWIG_arg_fail(1)) SWIG_fail;
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19838
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj;
19853 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19854 bool result;
19855 PyObject * obj0 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "self", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19862 if (SWIG_arg_fail(1)) SWIG_fail;
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19866
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 {
19871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19872 }
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19880 PyObject *obj;
19881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19882 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19883 Py_INCREF(obj);
19884 return Py_BuildValue((char *)"");
19885 }
19886 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19887 PyObject *resultobj;
19888 int arg1 = (int) 0 ;
19889 bool arg2 = (bool) false ;
19890 wxShowEvent *result;
19891 PyObject * obj0 = 0 ;
19892 PyObject * obj1 = 0 ;
19893 char *kwnames[] = {
19894 (char *) "winid",(char *) "show", NULL
19895 };
19896
19897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19898 if (obj0) {
19899 {
19900 arg1 = (int)(SWIG_As_int(obj0));
19901 if (SWIG_arg_fail(1)) SWIG_fail;
19902 }
19903 }
19904 if (obj1) {
19905 {
19906 arg2 = (bool)(SWIG_As_bool(obj1));
19907 if (SWIG_arg_fail(2)) SWIG_fail;
19908 }
19909 }
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19913
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj;
19926 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19927 bool arg2 ;
19928 PyObject * obj0 = 0 ;
19929 PyObject * obj1 = 0 ;
19930 char *kwnames[] = {
19931 (char *) "self",(char *) "show", NULL
19932 };
19933
19934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19936 if (SWIG_arg_fail(1)) SWIG_fail;
19937 {
19938 arg2 = (bool)(SWIG_As_bool(obj1));
19939 if (SWIG_arg_fail(2)) SWIG_fail;
19940 }
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 (arg1)->SetShow(arg2);
19944
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 Py_INCREF(Py_None); resultobj = Py_None;
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj;
19957 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19958 bool result;
19959 PyObject * obj0 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19970
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 {
19975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19976 }
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19984 PyObject *obj;
19985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19986 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19987 Py_INCREF(obj);
19988 return Py_BuildValue((char *)"");
19989 }
19990 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19991 PyObject *resultobj;
19992 int arg1 = (int) 0 ;
19993 bool arg2 = (bool) true ;
19994 wxIconizeEvent *result;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 char *kwnames[] = {
19998 (char *) "id",(char *) "iconized", NULL
19999 };
20000
20001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20002 if (obj0) {
20003 {
20004 arg1 = (int)(SWIG_As_int(obj0));
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 }
20007 }
20008 if (obj1) {
20009 {
20010 arg2 = (bool)(SWIG_As_bool(obj1));
20011 if (SWIG_arg_fail(2)) SWIG_fail;
20012 }
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20031 bool result;
20032 PyObject * obj0 = 0 ;
20033 char *kwnames[] = {
20034 (char *) "self", NULL
20035 };
20036
20037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20039 if (SWIG_arg_fail(1)) SWIG_fail;
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (bool)(arg1)->Iconized();
20043
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20049 }
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20057 PyObject *obj;
20058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20059 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20060 Py_INCREF(obj);
20061 return Py_BuildValue((char *)"");
20062 }
20063 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj;
20065 int arg1 = (int) 0 ;
20066 wxMaximizeEvent *result;
20067 PyObject * obj0 = 0 ;
20068 char *kwnames[] = {
20069 (char *) "id", NULL
20070 };
20071
20072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20073 if (obj0) {
20074 {
20075 arg1 = (int)(SWIG_As_int(obj0));
20076 if (SWIG_arg_fail(1)) SWIG_fail;
20077 }
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20082
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20094 PyObject *obj;
20095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20096 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20097 Py_INCREF(obj);
20098 return Py_BuildValue((char *)"");
20099 }
20100 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj;
20102 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20103 wxPoint result;
20104 PyObject * obj0 = 0 ;
20105 char *kwnames[] = {
20106 (char *) "self", NULL
20107 };
20108
20109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20111 if (SWIG_arg_fail(1)) SWIG_fail;
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (arg1)->GetPosition();
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 {
20120 wxPoint * resultptr;
20121 resultptr = new wxPoint((wxPoint &)(result));
20122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20123 }
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj;
20132 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20133 int result;
20134 PyObject * obj0 = 0 ;
20135 char *kwnames[] = {
20136 (char *) "self", NULL
20137 };
20138
20139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20141 if (SWIG_arg_fail(1)) SWIG_fail;
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (int)(arg1)->GetNumberOfFiles();
20145
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 {
20150 resultobj = SWIG_From_int((int)(result));
20151 }
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20159 PyObject *resultobj;
20160 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20161 PyObject *result;
20162 PyObject * obj0 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 PyThreadState* __tstate = wxPyBeginAllowThreads();
20172 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20173
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = result;
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20185 PyObject *obj;
20186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20187 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20188 Py_INCREF(obj);
20189 return Py_BuildValue((char *)"");
20190 }
20191 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 int arg1 = (int) 0 ;
20194 wxUpdateUIEvent *result;
20195 PyObject * obj0 = 0 ;
20196 char *kwnames[] = {
20197 (char *) "commandId", NULL
20198 };
20199
20200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20201 if (obj0) {
20202 {
20203 arg1 = (int)(SWIG_As_int(obj0));
20204 if (SWIG_arg_fail(1)) SWIG_fail;
20205 }
20206 }
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj;
20223 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20224 bool result;
20225 PyObject * obj0 = 0 ;
20226 char *kwnames[] = {
20227 (char *) "self", NULL
20228 };
20229
20230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20232 if (SWIG_arg_fail(1)) SWIG_fail;
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 {
20241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20242 }
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj;
20251 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20252 bool result;
20253 PyObject * obj0 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20270 }
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20278 PyObject *resultobj;
20279 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20280 wxString result;
20281 PyObject * obj0 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 PyThreadState* __tstate = wxPyBeginAllowThreads();
20291 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20292
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 {
20297 #if wxUSE_UNICODE
20298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20299 #else
20300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20301 #endif
20302 }
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20312 bool result;
20313 PyObject * obj0 = 0 ;
20314 char *kwnames[] = {
20315 (char *) "self", NULL
20316 };
20317
20318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20320 if (SWIG_arg_fail(1)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20330 }
20331 return resultobj;
20332 fail:
20333 return NULL;
20334 }
20335
20336
20337 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20338 PyObject *resultobj;
20339 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20340 bool result;
20341 PyObject * obj0 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20358 }
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20368 bool result;
20369 PyObject * obj0 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20380
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20386 }
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj;
20395 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20396 bool arg2 ;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 char *kwnames[] = {
20400 (char *) "self",(char *) "check", NULL
20401 };
20402
20403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, 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)->Check(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_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj;
20426 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20427 bool arg2 ;
20428 PyObject * obj0 = 0 ;
20429 PyObject * obj1 = 0 ;
20430 char *kwnames[] = {
20431 (char *) "self",(char *) "enable", NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(1)) SWIG_fail;
20437 {
20438 arg2 = (bool)(SWIG_As_bool(obj1));
20439 if (SWIG_arg_fail(2)) SWIG_fail;
20440 }
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 (arg1)->Enable(arg2);
20444
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 Py_INCREF(Py_None); resultobj = Py_None;
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj;
20457 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20458 wxString *arg2 = 0 ;
20459 bool temp2 = false ;
20460 PyObject * obj0 = 0 ;
20461 PyObject * obj1 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "self",(char *) "text", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 {
20470 arg2 = wxString_in_helper(obj1);
20471 if (arg2 == NULL) SWIG_fail;
20472 temp2 = true;
20473 }
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 (arg1)->SetText((wxString const &)*arg2);
20477
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 Py_INCREF(Py_None); resultobj = Py_None;
20482 {
20483 if (temp2)
20484 delete arg2;
20485 }
20486 return resultobj;
20487 fail:
20488 {
20489 if (temp2)
20490 delete arg2;
20491 }
20492 return NULL;
20493 }
20494
20495
20496 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj;
20498 long arg1 ;
20499 PyObject * obj0 = 0 ;
20500 char *kwnames[] = {
20501 (char *) "updateInterval", NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20505 {
20506 arg1 = (long)(SWIG_As_long(obj0));
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 }
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 wxUpdateUIEvent::SetUpdateInterval(arg1);
20512
20513 wxPyEndAllowThreads(__tstate);
20514 if (PyErr_Occurred()) SWIG_fail;
20515 }
20516 Py_INCREF(Py_None); resultobj = Py_None;
20517 return resultobj;
20518 fail:
20519 return NULL;
20520 }
20521
20522
20523 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20524 PyObject *resultobj;
20525 long result;
20526 char *kwnames[] = {
20527 NULL
20528 };
20529
20530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = SWIG_From_long((long)(result));
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxWindow *arg1 = (wxWindow *) 0 ;
20550 bool result;
20551 PyObject * obj0 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "win", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20576 PyObject *resultobj;
20577 char *kwnames[] = {
20578 NULL
20579 };
20580
20581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20582 {
20583 PyThreadState* __tstate = wxPyBeginAllowThreads();
20584 wxUpdateUIEvent::ResetUpdateTime();
20585
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 Py_INCREF(Py_None); resultobj = Py_None;
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj;
20598 wxUpdateUIMode arg1 ;
20599 PyObject * obj0 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "mode", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20605 {
20606 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20607 if (SWIG_arg_fail(1)) SWIG_fail;
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 Py_INCREF(Py_None); resultobj = Py_None;
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20624 PyObject *resultobj;
20625 wxUpdateUIMode result;
20626 char *kwnames[] = {
20627 NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20634
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 resultobj = SWIG_From_int((result));
20639 return resultobj;
20640 fail:
20641 return NULL;
20642 }
20643
20644
20645 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20646 PyObject *obj;
20647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20648 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20649 Py_INCREF(obj);
20650 return Py_BuildValue((char *)"");
20651 }
20652 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj;
20654 wxSysColourChangedEvent *result;
20655 char *kwnames[] = {
20656 NULL
20657 };
20658
20659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20663
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20675 PyObject *obj;
20676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20677 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20678 Py_INCREF(obj);
20679 return Py_BuildValue((char *)"");
20680 }
20681 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20682 PyObject *resultobj;
20683 int arg1 = (int) 0 ;
20684 wxWindow *arg2 = (wxWindow *) NULL ;
20685 wxMouseCaptureChangedEvent *result;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "winid",(char *) "gainedCapture", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20693 if (obj0) {
20694 {
20695 arg1 = (int)(SWIG_As_int(obj0));
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 }
20698 }
20699 if (obj1) {
20700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20701 if (SWIG_arg_fail(2)) SWIG_fail;
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20706
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20718 PyObject *resultobj;
20719 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20720 wxWindow *result;
20721 PyObject * obj0 = 0 ;
20722 char *kwnames[] = {
20723 (char *) "self", NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(1)) SWIG_fail;
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = wxPyMake_wxObject(result, 0);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20746 PyObject *obj;
20747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20748 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20749 Py_INCREF(obj);
20750 return Py_BuildValue((char *)"");
20751 }
20752 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20753 PyObject *resultobj;
20754 wxDisplayChangedEvent *result;
20755 char *kwnames[] = {
20756 NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20763
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20775 PyObject *obj;
20776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20777 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20778 Py_INCREF(obj);
20779 return Py_BuildValue((char *)"");
20780 }
20781 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20782 PyObject *resultobj;
20783 int arg1 = (int) 0 ;
20784 wxPaletteChangedEvent *result;
20785 PyObject * obj0 = 0 ;
20786 char *kwnames[] = {
20787 (char *) "id", NULL
20788 };
20789
20790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20791 if (obj0) {
20792 {
20793 arg1 = (int)(SWIG_As_int(obj0));
20794 if (SWIG_arg_fail(1)) SWIG_fail;
20795 }
20796 }
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20800
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20812 PyObject *resultobj;
20813 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20814 wxWindow *arg2 = (wxWindow *) 0 ;
20815 PyObject * obj0 = 0 ;
20816 PyObject * obj1 = 0 ;
20817 char *kwnames[] = {
20818 (char *) "self",(char *) "win", NULL
20819 };
20820
20821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20823 if (SWIG_arg_fail(1)) SWIG_fail;
20824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(2)) SWIG_fail;
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 (arg1)->SetChangedWindow(arg2);
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 Py_INCREF(Py_None); resultobj = Py_None;
20834 return resultobj;
20835 fail:
20836 return NULL;
20837 }
20838
20839
20840 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20841 PyObject *resultobj;
20842 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20843 wxWindow *result;
20844 PyObject * obj0 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "self", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20851 if (SWIG_arg_fail(1)) SWIG_fail;
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (wxWindow *)(arg1)->GetChangedWindow();
20855
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 resultobj = wxPyMake_wxObject(result, 0);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20869 PyObject *obj;
20870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20871 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20872 Py_INCREF(obj);
20873 return Py_BuildValue((char *)"");
20874 }
20875 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 int arg1 = (int) 0 ;
20878 wxQueryNewPaletteEvent *result;
20879 PyObject * obj0 = 0 ;
20880 char *kwnames[] = {
20881 (char *) "winid", NULL
20882 };
20883
20884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20885 if (obj0) {
20886 {
20887 arg1 = (int)(SWIG_As_int(obj0));
20888 if (SWIG_arg_fail(1)) SWIG_fail;
20889 }
20890 }
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20894
20895 wxPyEndAllowThreads(__tstate);
20896 if (PyErr_Occurred()) SWIG_fail;
20897 }
20898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj;
20907 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20908 bool arg2 ;
20909 PyObject * obj0 = 0 ;
20910 PyObject * obj1 = 0 ;
20911 char *kwnames[] = {
20912 (char *) "self",(char *) "realized", NULL
20913 };
20914
20915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20917 if (SWIG_arg_fail(1)) SWIG_fail;
20918 {
20919 arg2 = (bool)(SWIG_As_bool(obj1));
20920 if (SWIG_arg_fail(2)) SWIG_fail;
20921 }
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 (arg1)->SetPaletteRealized(arg2);
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 Py_INCREF(Py_None); resultobj = Py_None;
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20937 PyObject *resultobj;
20938 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20939 bool result;
20940 PyObject * obj0 = 0 ;
20941 char *kwnames[] = {
20942 (char *) "self", NULL
20943 };
20944
20945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20947 if (SWIG_arg_fail(1)) SWIG_fail;
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20951
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20965 PyObject *obj;
20966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20967 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20968 Py_INCREF(obj);
20969 return Py_BuildValue((char *)"");
20970 }
20971 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20972 PyObject *resultobj;
20973 wxNavigationKeyEvent *result;
20974 char *kwnames[] = {
20975 NULL
20976 };
20977
20978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20979 {
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20982
20983 wxPyEndAllowThreads(__tstate);
20984 if (PyErr_Occurred()) SWIG_fail;
20985 }
20986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj;
20995 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20996 bool result;
20997 PyObject * obj0 = 0 ;
20998 char *kwnames[] = {
20999 (char *) "self", NULL
21000 };
21001
21002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21004 if (SWIG_arg_fail(1)) SWIG_fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21008
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 {
21013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21014 }
21015 return resultobj;
21016 fail:
21017 return NULL;
21018 }
21019
21020
21021 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21022 PyObject *resultobj;
21023 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21024 bool arg2 ;
21025 PyObject * obj0 = 0 ;
21026 PyObject * obj1 = 0 ;
21027 char *kwnames[] = {
21028 (char *) "self",(char *) "forward", NULL
21029 };
21030
21031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21033 if (SWIG_arg_fail(1)) SWIG_fail;
21034 {
21035 arg2 = (bool)(SWIG_As_bool(obj1));
21036 if (SWIG_arg_fail(2)) SWIG_fail;
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 (arg1)->SetDirection(arg2);
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 Py_INCREF(Py_None); resultobj = Py_None;
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj;
21054 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21055 bool result;
21056 PyObject * obj0 = 0 ;
21057 char *kwnames[] = {
21058 (char *) "self", NULL
21059 };
21060
21061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21063 if (SWIG_arg_fail(1)) SWIG_fail;
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21067
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 {
21072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21073 }
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj;
21082 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21083 bool arg2 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 char *kwnames[] = {
21087 (char *) "self",(char *) "ischange", NULL
21088 };
21089
21090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21092 if (SWIG_arg_fail(1)) SWIG_fail;
21093 {
21094 arg2 = (bool)(SWIG_As_bool(obj1));
21095 if (SWIG_arg_fail(2)) SWIG_fail;
21096 }
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 (arg1)->SetWindowChange(arg2);
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 Py_INCREF(Py_None); resultobj = Py_None;
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21114 long arg2 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char *kwnames[] = {
21118 (char *) "self",(char *) "flags", NULL
21119 };
21120
21121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21123 if (SWIG_arg_fail(1)) SWIG_fail;
21124 {
21125 arg2 = (long)(SWIG_As_long(obj1));
21126 if (SWIG_arg_fail(2)) SWIG_fail;
21127 }
21128 {
21129 PyThreadState* __tstate = wxPyBeginAllowThreads();
21130 (arg1)->SetFlags(arg2);
21131
21132 wxPyEndAllowThreads(__tstate);
21133 if (PyErr_Occurred()) SWIG_fail;
21134 }
21135 Py_INCREF(Py_None); resultobj = Py_None;
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21145 wxWindow *result;
21146 PyObject * obj0 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21157
21158 wxPyEndAllowThreads(__tstate);
21159 if (PyErr_Occurred()) SWIG_fail;
21160 }
21161 {
21162 resultobj = wxPyMake_wxObject(result, 0);
21163 }
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21173 wxWindow *arg2 = (wxWindow *) 0 ;
21174 PyObject * obj0 = 0 ;
21175 PyObject * obj1 = 0 ;
21176 char *kwnames[] = {
21177 (char *) "self",(char *) "win", NULL
21178 };
21179
21180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21182 if (SWIG_arg_fail(1)) SWIG_fail;
21183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21184 if (SWIG_arg_fail(2)) SWIG_fail;
21185 {
21186 PyThreadState* __tstate = wxPyBeginAllowThreads();
21187 (arg1)->SetCurrentFocus(arg2);
21188
21189 wxPyEndAllowThreads(__tstate);
21190 if (PyErr_Occurred()) SWIG_fail;
21191 }
21192 Py_INCREF(Py_None); resultobj = Py_None;
21193 return resultobj;
21194 fail:
21195 return NULL;
21196 }
21197
21198
21199 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21200 PyObject *obj;
21201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21202 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21203 Py_INCREF(obj);
21204 return Py_BuildValue((char *)"");
21205 }
21206 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxWindow *arg1 = (wxWindow *) NULL ;
21209 wxWindowCreateEvent *result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "win", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21216 if (obj0) {
21217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21218 if (SWIG_arg_fail(1)) SWIG_fail;
21219 }
21220 {
21221 PyThreadState* __tstate = wxPyBeginAllowThreads();
21222 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21223
21224 wxPyEndAllowThreads(__tstate);
21225 if (PyErr_Occurred()) SWIG_fail;
21226 }
21227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21237 wxWindow *result;
21238 PyObject * obj0 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = wxPyMake_wxObject(result, 0);
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21263 PyObject *obj;
21264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21265 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21266 Py_INCREF(obj);
21267 return Py_BuildValue((char *)"");
21268 }
21269 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 wxWindow *arg1 = (wxWindow *) NULL ;
21272 wxWindowDestroyEvent *result;
21273 PyObject * obj0 = 0 ;
21274 char *kwnames[] = {
21275 (char *) "win", NULL
21276 };
21277
21278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21279 if (obj0) {
21280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21281 if (SWIG_arg_fail(1)) SWIG_fail;
21282 }
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21286
21287 wxPyEndAllowThreads(__tstate);
21288 if (PyErr_Occurred()) SWIG_fail;
21289 }
21290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj;
21299 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21300 wxWindow *result;
21301 PyObject * obj0 = 0 ;
21302 char *kwnames[] = {
21303 (char *) "self", NULL
21304 };
21305
21306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21308 if (SWIG_arg_fail(1)) SWIG_fail;
21309 {
21310 PyThreadState* __tstate = wxPyBeginAllowThreads();
21311 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21312
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = wxPyMake_wxObject(result, 0);
21318 }
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21326 PyObject *obj;
21327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21328 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21329 Py_INCREF(obj);
21330 return Py_BuildValue((char *)"");
21331 }
21332 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj;
21334 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21335 int arg2 = (int) 0 ;
21336 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21337 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21338 wxContextMenuEvent *result;
21339 wxPoint temp3 ;
21340 PyObject * obj0 = 0 ;
21341 PyObject * obj1 = 0 ;
21342 PyObject * obj2 = 0 ;
21343 char *kwnames[] = {
21344 (char *) "type",(char *) "winid",(char *) "pt", NULL
21345 };
21346
21347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21348 if (obj0) {
21349 {
21350 arg1 = (wxEventType)(SWIG_As_int(obj0));
21351 if (SWIG_arg_fail(1)) SWIG_fail;
21352 }
21353 }
21354 if (obj1) {
21355 {
21356 arg2 = (int)(SWIG_As_int(obj1));
21357 if (SWIG_arg_fail(2)) SWIG_fail;
21358 }
21359 }
21360 if (obj2) {
21361 {
21362 arg3 = &temp3;
21363 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21369
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21374 return resultobj;
21375 fail:
21376 return NULL;
21377 }
21378
21379
21380 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj;
21382 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21383 wxPoint *result;
21384 PyObject * obj0 = 0 ;
21385 char *kwnames[] = {
21386 (char *) "self", NULL
21387 };
21388
21389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21391 if (SWIG_arg_fail(1)) SWIG_fail;
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 {
21395 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21396 result = (wxPoint *) &_result_ref;
21397 }
21398
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj;
21411 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21412 wxPoint *arg2 = 0 ;
21413 wxPoint temp2 ;
21414 PyObject * obj0 = 0 ;
21415 PyObject * obj1 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self",(char *) "pos", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 arg2 = &temp2;
21425 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21426 }
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 (arg1)->SetPosition((wxPoint const &)*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 * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21442 PyObject *obj;
21443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21444 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21445 Py_INCREF(obj);
21446 return Py_BuildValue((char *)"");
21447 }
21448 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj;
21450 wxIdleEvent *result;
21451 char *kwnames[] = {
21452 NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21456 {
21457 PyThreadState* __tstate = wxPyBeginAllowThreads();
21458 result = (wxIdleEvent *)new wxIdleEvent();
21459
21460 wxPyEndAllowThreads(__tstate);
21461 if (PyErr_Occurred()) SWIG_fail;
21462 }
21463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj;
21472 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21473 bool arg2 = (bool) true ;
21474 PyObject * obj0 = 0 ;
21475 PyObject * obj1 = 0 ;
21476 char *kwnames[] = {
21477 (char *) "self",(char *) "needMore", NULL
21478 };
21479
21480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21482 if (SWIG_arg_fail(1)) SWIG_fail;
21483 if (obj1) {
21484 {
21485 arg2 = (bool)(SWIG_As_bool(obj1));
21486 if (SWIG_arg_fail(2)) SWIG_fail;
21487 }
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 (arg1)->RequestMore(arg2);
21492
21493 wxPyEndAllowThreads(__tstate);
21494 if (PyErr_Occurred()) SWIG_fail;
21495 }
21496 Py_INCREF(Py_None); resultobj = Py_None;
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21504 PyObject *resultobj;
21505 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21506 bool result;
21507 PyObject * obj0 = 0 ;
21508 char *kwnames[] = {
21509 (char *) "self", NULL
21510 };
21511
21512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21514 if (SWIG_arg_fail(1)) SWIG_fail;
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21518
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 {
21523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21524 }
21525 return resultobj;
21526 fail:
21527 return NULL;
21528 }
21529
21530
21531 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21532 PyObject *resultobj;
21533 wxIdleMode arg1 ;
21534 PyObject * obj0 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "mode", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21540 {
21541 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21542 if (SWIG_arg_fail(1)) SWIG_fail;
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 wxIdleEvent::SetMode((wxIdleMode )arg1);
21547
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 Py_INCREF(Py_None); resultobj = Py_None;
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj;
21560 wxIdleMode result;
21561 char *kwnames[] = {
21562 NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 result = (wxIdleMode)wxIdleEvent::GetMode();
21569
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 resultobj = SWIG_From_int((result));
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21581 PyObject *resultobj;
21582 wxWindow *arg1 = (wxWindow *) 0 ;
21583 bool result;
21584 PyObject * obj0 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "win", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (bool)wxIdleEvent::CanSend(arg1);
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 {
21600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21601 }
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21609 PyObject *obj;
21610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21611 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21612 Py_INCREF(obj);
21613 return Py_BuildValue((char *)"");
21614 }
21615 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21616 PyObject *resultobj;
21617 int arg1 = (int) 0 ;
21618 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21619 wxPyEvent *result;
21620 PyObject * obj0 = 0 ;
21621 PyObject * obj1 = 0 ;
21622 char *kwnames[] = {
21623 (char *) "winid",(char *) "commandType", NULL
21624 };
21625
21626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21627 if (obj0) {
21628 {
21629 arg1 = (int)(SWIG_As_int(obj0));
21630 if (SWIG_arg_fail(1)) SWIG_fail;
21631 }
21632 }
21633 if (obj1) {
21634 {
21635 arg2 = (wxEventType)(SWIG_As_int(obj1));
21636 if (SWIG_arg_fail(2)) SWIG_fail;
21637 }
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21654 PyObject *resultobj;
21655 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21656 PyObject * obj0 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "self", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21663 if (SWIG_arg_fail(1)) SWIG_fail;
21664 {
21665 PyThreadState* __tstate = wxPyBeginAllowThreads();
21666 delete arg1;
21667
21668 wxPyEndAllowThreads(__tstate);
21669 if (PyErr_Occurred()) SWIG_fail;
21670 }
21671 Py_INCREF(Py_None); resultobj = Py_None;
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj;
21680 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21681 PyObject *arg2 = (PyObject *) 0 ;
21682 PyObject * obj0 = 0 ;
21683 PyObject * obj1 = 0 ;
21684 char *kwnames[] = {
21685 (char *) "self",(char *) "self", NULL
21686 };
21687
21688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21690 if (SWIG_arg_fail(1)) SWIG_fail;
21691 arg2 = obj1;
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 (arg1)->SetSelf(arg2);
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 Py_INCREF(Py_None); resultobj = Py_None;
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21709 PyObject *result;
21710 PyObject * obj0 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (PyObject *)(arg1)->GetSelf();
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 resultobj = result;
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21733 PyObject *obj;
21734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21735 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21736 Py_INCREF(obj);
21737 return Py_BuildValue((char *)"");
21738 }
21739 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj;
21741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21742 int arg2 = (int) 0 ;
21743 wxPyCommandEvent *result;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "commandType",(char *) "id", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21751 if (obj0) {
21752 {
21753 arg1 = (wxEventType)(SWIG_As_int(obj0));
21754 if (SWIG_arg_fail(1)) SWIG_fail;
21755 }
21756 }
21757 if (obj1) {
21758 {
21759 arg2 = (int)(SWIG_As_int(obj1));
21760 if (SWIG_arg_fail(2)) SWIG_fail;
21761 }
21762 }
21763 {
21764 PyThreadState* __tstate = wxPyBeginAllowThreads();
21765 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21766
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21778 PyObject *resultobj;
21779 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21780 PyObject * obj0 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 delete arg1;
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_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21803 PyObject *resultobj;
21804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21805 PyObject *arg2 = (PyObject *) 0 ;
21806 PyObject * obj0 = 0 ;
21807 PyObject * obj1 = 0 ;
21808 char *kwnames[] = {
21809 (char *) "self",(char *) "self", NULL
21810 };
21811
21812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21814 if (SWIG_arg_fail(1)) SWIG_fail;
21815 arg2 = obj1;
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 (arg1)->SetSelf(arg2);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 Py_INCREF(Py_None); resultobj = Py_None;
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21833 PyObject *result;
21834 PyObject * obj0 = 0 ;
21835 char *kwnames[] = {
21836 (char *) "self", NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21841 if (SWIG_arg_fail(1)) SWIG_fail;
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 result = (PyObject *)(arg1)->GetSelf();
21845
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 resultobj = result;
21850 return resultobj;
21851 fail:
21852 return NULL;
21853 }
21854
21855
21856 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21857 PyObject *obj;
21858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21859 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21860 Py_INCREF(obj);
21861 return Py_BuildValue((char *)"");
21862 }
21863 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj;
21865 wxPyApp *result;
21866 char *kwnames[] = {
21867 NULL
21868 };
21869
21870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxPyApp *)new_wxPyApp();
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxPyApp *arg1 = (wxPyApp *) 0 ;
21888 PyObject * obj0 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 delete arg1;
21899
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 Py_INCREF(Py_None); resultobj = Py_None;
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21911 PyObject *resultobj;
21912 wxPyApp *arg1 = (wxPyApp *) 0 ;
21913 PyObject *arg2 = (PyObject *) 0 ;
21914 PyObject *arg3 = (PyObject *) 0 ;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 PyObject * obj2 = 0 ;
21918 char *kwnames[] = {
21919 (char *) "self",(char *) "self",(char *) "_class", NULL
21920 };
21921
21922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21924 if (SWIG_arg_fail(1)) SWIG_fail;
21925 arg2 = obj1;
21926 arg3 = obj2;
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 (arg1)->_setCallbackInfo(arg2,arg3);
21930
21931 wxPyEndAllowThreads(__tstate);
21932 if (PyErr_Occurred()) SWIG_fail;
21933 }
21934 Py_INCREF(Py_None); resultobj = Py_None;
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21942 PyObject *resultobj;
21943 wxPyApp *arg1 = (wxPyApp *) 0 ;
21944 wxString result;
21945 PyObject * obj0 = 0 ;
21946 char *kwnames[] = {
21947 (char *) "self", NULL
21948 };
21949
21950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21952 if (SWIG_arg_fail(1)) SWIG_fail;
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = ((wxPyApp const *)arg1)->GetAppName();
21956
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 #if wxUSE_UNICODE
21962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21963 #else
21964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21965 #endif
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21974 PyObject *resultobj;
21975 wxPyApp *arg1 = (wxPyApp *) 0 ;
21976 wxString *arg2 = 0 ;
21977 bool temp2 = false ;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "name", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 {
21988 arg2 = wxString_in_helper(obj1);
21989 if (arg2 == NULL) SWIG_fail;
21990 temp2 = true;
21991 }
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 (arg1)->SetAppName((wxString const &)*arg2);
21995
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 Py_INCREF(Py_None); resultobj = Py_None;
22000 {
22001 if (temp2)
22002 delete arg2;
22003 }
22004 return resultobj;
22005 fail:
22006 {
22007 if (temp2)
22008 delete arg2;
22009 }
22010 return NULL;
22011 }
22012
22013
22014 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22015 PyObject *resultobj;
22016 wxPyApp *arg1 = (wxPyApp *) 0 ;
22017 wxString result;
22018 PyObject * obj0 = 0 ;
22019 char *kwnames[] = {
22020 (char *) "self", NULL
22021 };
22022
22023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(1)) SWIG_fail;
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = ((wxPyApp const *)arg1)->GetClassName();
22029
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 #if wxUSE_UNICODE
22035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22036 #else
22037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22038 #endif
22039 }
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxPyApp *arg1 = (wxPyApp *) 0 ;
22049 wxString *arg2 = 0 ;
22050 bool temp2 = false ;
22051 PyObject * obj0 = 0 ;
22052 PyObject * obj1 = 0 ;
22053 char *kwnames[] = {
22054 (char *) "self",(char *) "name", NULL
22055 };
22056
22057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22059 if (SWIG_arg_fail(1)) SWIG_fail;
22060 {
22061 arg2 = wxString_in_helper(obj1);
22062 if (arg2 == NULL) SWIG_fail;
22063 temp2 = true;
22064 }
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 (arg1)->SetClassName((wxString const &)*arg2);
22068
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 Py_INCREF(Py_None); resultobj = Py_None;
22073 {
22074 if (temp2)
22075 delete arg2;
22076 }
22077 return resultobj;
22078 fail:
22079 {
22080 if (temp2)
22081 delete arg2;
22082 }
22083 return NULL;
22084 }
22085
22086
22087 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22088 PyObject *resultobj;
22089 wxPyApp *arg1 = (wxPyApp *) 0 ;
22090 wxString *result;
22091 PyObject * obj0 = 0 ;
22092 char *kwnames[] = {
22093 (char *) "self", NULL
22094 };
22095
22096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22098 if (SWIG_arg_fail(1)) SWIG_fail;
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 {
22102 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22103 result = (wxString *) &_result_ref;
22104 }
22105
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 #if wxUSE_UNICODE
22111 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22112 #else
22113 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22114 #endif
22115 }
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj;
22124 wxPyApp *arg1 = (wxPyApp *) 0 ;
22125 wxString *arg2 = 0 ;
22126 bool temp2 = false ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 char *kwnames[] = {
22130 (char *) "self",(char *) "name", NULL
22131 };
22132
22133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22135 if (SWIG_arg_fail(1)) SWIG_fail;
22136 {
22137 arg2 = wxString_in_helper(obj1);
22138 if (arg2 == NULL) SWIG_fail;
22139 temp2 = true;
22140 }
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 (arg1)->SetVendorName((wxString const &)*arg2);
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 Py_INCREF(Py_None); resultobj = Py_None;
22149 {
22150 if (temp2)
22151 delete arg2;
22152 }
22153 return resultobj;
22154 fail:
22155 {
22156 if (temp2)
22157 delete arg2;
22158 }
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj;
22165 wxPyApp *arg1 = (wxPyApp *) 0 ;
22166 wxAppTraits *result;
22167 PyObject * obj0 = 0 ;
22168 char *kwnames[] = {
22169 (char *) "self", NULL
22170 };
22171
22172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22174 if (SWIG_arg_fail(1)) SWIG_fail;
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 result = (wxAppTraits *)(arg1)->GetTraits();
22178
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxPyApp *arg1 = (wxPyApp *) 0 ;
22192 PyObject * obj0 = 0 ;
22193 char *kwnames[] = {
22194 (char *) "self", NULL
22195 };
22196
22197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22199 if (SWIG_arg_fail(1)) SWIG_fail;
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 (arg1)->ProcessPendingEvents();
22203
22204 wxPyEndAllowThreads(__tstate);
22205 if (PyErr_Occurred()) SWIG_fail;
22206 }
22207 Py_INCREF(Py_None); resultobj = Py_None;
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj;
22216 wxPyApp *arg1 = (wxPyApp *) 0 ;
22217 bool arg2 = (bool) false ;
22218 bool result;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char *kwnames[] = {
22222 (char *) "self",(char *) "onlyIfNeeded", NULL
22223 };
22224
22225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22227 if (SWIG_arg_fail(1)) SWIG_fail;
22228 if (obj1) {
22229 {
22230 arg2 = (bool)(SWIG_As_bool(obj1));
22231 if (SWIG_arg_fail(2)) SWIG_fail;
22232 }
22233 }
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (bool)(arg1)->Yield(arg2);
22237
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 {
22242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22243 }
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22251 PyObject *resultobj;
22252 wxPyApp *arg1 = (wxPyApp *) 0 ;
22253 PyObject * obj0 = 0 ;
22254 char *kwnames[] = {
22255 (char *) "self", NULL
22256 };
22257
22258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22260 if (SWIG_arg_fail(1)) SWIG_fail;
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 (arg1)->WakeUpIdle();
22264
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 Py_INCREF(Py_None); resultobj = Py_None;
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj;
22277 bool result;
22278 char *kwnames[] = {
22279 NULL
22280 };
22281
22282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (bool)wxPyApp::IsMainLoopRunning();
22286
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxPyApp *arg1 = (wxPyApp *) 0 ;
22302 int result;
22303 PyObject * obj0 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (int)(arg1)->MainLoop();
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = SWIG_From_int((int)(result));
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj;
22329 wxPyApp *arg1 = (wxPyApp *) 0 ;
22330 PyObject * obj0 = 0 ;
22331 char *kwnames[] = {
22332 (char *) "self", NULL
22333 };
22334
22335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22337 if (SWIG_arg_fail(1)) SWIG_fail;
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 (arg1)->Exit();
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 Py_INCREF(Py_None); resultobj = Py_None;
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxPyApp *arg1 = (wxPyApp *) 0 ;
22355 PyObject * obj0 = 0 ;
22356 char *kwnames[] = {
22357 (char *) "self", NULL
22358 };
22359
22360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22362 if (SWIG_arg_fail(1)) SWIG_fail;
22363 {
22364 PyThreadState* __tstate = wxPyBeginAllowThreads();
22365 (arg1)->ExitMainLoop();
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 Py_INCREF(Py_None); resultobj = Py_None;
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22378 PyObject *resultobj;
22379 wxPyApp *arg1 = (wxPyApp *) 0 ;
22380 bool result;
22381 PyObject * obj0 = 0 ;
22382 char *kwnames[] = {
22383 (char *) "self", NULL
22384 };
22385
22386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22388 if (SWIG_arg_fail(1)) SWIG_fail;
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)(arg1)->Pending();
22392
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 {
22397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22398 }
22399 return resultobj;
22400 fail:
22401 return NULL;
22402 }
22403
22404
22405 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22406 PyObject *resultobj;
22407 wxPyApp *arg1 = (wxPyApp *) 0 ;
22408 bool result;
22409 PyObject * obj0 = 0 ;
22410 char *kwnames[] = {
22411 (char *) "self", NULL
22412 };
22413
22414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22416 if (SWIG_arg_fail(1)) SWIG_fail;
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = (bool)(arg1)->Dispatch();
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 {
22425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22426 }
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22434 PyObject *resultobj;
22435 wxPyApp *arg1 = (wxPyApp *) 0 ;
22436 bool result;
22437 PyObject * obj0 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 result = (bool)(arg1)->ProcessIdle();
22448
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 {
22453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22454 }
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxPyApp *arg1 = (wxPyApp *) 0 ;
22464 wxWindow *arg2 = (wxWindow *) 0 ;
22465 wxIdleEvent *arg3 = 0 ;
22466 bool result;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 PyObject * obj2 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self",(char *) "win",(char *) "event", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(2)) SWIG_fail;
22479 {
22480 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22481 if (SWIG_arg_fail(3)) SWIG_fail;
22482 if (arg3 == NULL) {
22483 SWIG_null_ref("wxIdleEvent");
22484 }
22485 if (SWIG_arg_fail(3)) SWIG_fail;
22486 }
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22490
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 {
22495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22496 }
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxPyApp *arg1 = (wxPyApp *) 0 ;
22506 bool result;
22507 PyObject * obj0 = 0 ;
22508 char *kwnames[] = {
22509 (char *) "self", NULL
22510 };
22511
22512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 result = (bool)((wxPyApp const *)arg1)->IsActive();
22518
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 {
22523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22524 }
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22532 PyObject *resultobj;
22533 wxPyApp *arg1 = (wxPyApp *) 0 ;
22534 wxWindow *arg2 = (wxWindow *) 0 ;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 char *kwnames[] = {
22538 (char *) "self",(char *) "win", NULL
22539 };
22540
22541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(1)) SWIG_fail;
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 (arg1)->SetTopWindow(arg2);
22549
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 Py_INCREF(Py_None); resultobj = Py_None;
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj;
22562 wxPyApp *arg1 = (wxPyApp *) 0 ;
22563 wxWindow *result;
22564 PyObject * obj0 = 0 ;
22565 char *kwnames[] = {
22566 (char *) "self", NULL
22567 };
22568
22569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22571 if (SWIG_arg_fail(1)) SWIG_fail;
22572 {
22573 PyThreadState* __tstate = wxPyBeginAllowThreads();
22574 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 {
22580 resultobj = wxPyMake_wxObject(result, 0);
22581 }
22582 return resultobj;
22583 fail:
22584 return NULL;
22585 }
22586
22587
22588 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22589 PyObject *resultobj;
22590 wxPyApp *arg1 = (wxPyApp *) 0 ;
22591 bool arg2 ;
22592 PyObject * obj0 = 0 ;
22593 PyObject * obj1 = 0 ;
22594 char *kwnames[] = {
22595 (char *) "self",(char *) "flag", NULL
22596 };
22597
22598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(1)) SWIG_fail;
22601 {
22602 arg2 = (bool)(SWIG_As_bool(obj1));
22603 if (SWIG_arg_fail(2)) SWIG_fail;
22604 }
22605 {
22606 PyThreadState* __tstate = wxPyBeginAllowThreads();
22607 (arg1)->SetExitOnFrameDelete(arg2);
22608
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 Py_INCREF(Py_None); resultobj = Py_None;
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22620 PyObject *resultobj;
22621 wxPyApp *arg1 = (wxPyApp *) 0 ;
22622 bool result;
22623 PyObject * obj0 = 0 ;
22624 char *kwnames[] = {
22625 (char *) "self", NULL
22626 };
22627
22628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22630 if (SWIG_arg_fail(1)) SWIG_fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 {
22639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22640 }
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22648 PyObject *resultobj;
22649 wxPyApp *arg1 = (wxPyApp *) 0 ;
22650 bool arg2 ;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653 char *kwnames[] = {
22654 (char *) "self",(char *) "flag", NULL
22655 };
22656
22657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 arg2 = (bool)(SWIG_As_bool(obj1));
22662 if (SWIG_arg_fail(2)) SWIG_fail;
22663 }
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 (arg1)->SetUseBestVisual(arg2);
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 Py_INCREF(Py_None); resultobj = Py_None;
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22679 PyObject *resultobj;
22680 wxPyApp *arg1 = (wxPyApp *) 0 ;
22681 bool result;
22682 PyObject * obj0 = 0 ;
22683 char *kwnames[] = {
22684 (char *) "self", NULL
22685 };
22686
22687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22689 if (SWIG_arg_fail(1)) SWIG_fail;
22690 {
22691 PyThreadState* __tstate = wxPyBeginAllowThreads();
22692 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22693
22694 wxPyEndAllowThreads(__tstate);
22695 if (PyErr_Occurred()) SWIG_fail;
22696 }
22697 {
22698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22699 }
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22707 PyObject *resultobj;
22708 wxPyApp *arg1 = (wxPyApp *) 0 ;
22709 int arg2 ;
22710 PyObject * obj0 = 0 ;
22711 PyObject * obj1 = 0 ;
22712 char *kwnames[] = {
22713 (char *) "self",(char *) "mode", NULL
22714 };
22715
22716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22718 if (SWIG_arg_fail(1)) SWIG_fail;
22719 {
22720 arg2 = (int)(SWIG_As_int(obj1));
22721 if (SWIG_arg_fail(2)) SWIG_fail;
22722 }
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 (arg1)->SetPrintMode(arg2);
22726
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 Py_INCREF(Py_None); resultobj = Py_None;
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22738 PyObject *resultobj;
22739 wxPyApp *arg1 = (wxPyApp *) 0 ;
22740 int result;
22741 PyObject * obj0 = 0 ;
22742 char *kwnames[] = {
22743 (char *) "self", NULL
22744 };
22745
22746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22748 if (SWIG_arg_fail(1)) SWIG_fail;
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22752
22753 wxPyEndAllowThreads(__tstate);
22754 if (PyErr_Occurred()) SWIG_fail;
22755 }
22756 {
22757 resultobj = SWIG_From_int((int)(result));
22758 }
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22766 PyObject *resultobj;
22767 wxPyApp *arg1 = (wxPyApp *) 0 ;
22768 int arg2 ;
22769 PyObject * obj0 = 0 ;
22770 PyObject * obj1 = 0 ;
22771 char *kwnames[] = {
22772 (char *) "self",(char *) "mode", NULL
22773 };
22774
22775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22777 if (SWIG_arg_fail(1)) SWIG_fail;
22778 {
22779 arg2 = (int)(SWIG_As_int(obj1));
22780 if (SWIG_arg_fail(2)) SWIG_fail;
22781 }
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 (arg1)->SetAssertMode(arg2);
22785
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 Py_INCREF(Py_None); resultobj = Py_None;
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj;
22798 wxPyApp *arg1 = (wxPyApp *) 0 ;
22799 int result;
22800 PyObject * obj0 = 0 ;
22801 char *kwnames[] = {
22802 (char *) "self", NULL
22803 };
22804
22805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(1)) SWIG_fail;
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (int)(arg1)->GetAssertMode();
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 {
22816 resultobj = SWIG_From_int((int)(result));
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj;
22826 bool result;
22827 char *kwnames[] = {
22828 NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22835
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 {
22840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22841 }
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj;
22850 long result;
22851 char *kwnames[] = {
22852 NULL
22853 };
22854
22855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (long)wxPyApp::GetMacAboutMenuItemId();
22859
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 {
22864 resultobj = SWIG_From_long((long)(result));
22865 }
22866 return resultobj;
22867 fail:
22868 return NULL;
22869 }
22870
22871
22872 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj;
22874 long result;
22875 char *kwnames[] = {
22876 NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22880 {
22881 PyThreadState* __tstate = wxPyBeginAllowThreads();
22882 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22883
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = SWIG_From_long((long)(result));
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj;
22898 long result;
22899 char *kwnames[] = {
22900 NULL
22901 };
22902
22903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 result = (long)wxPyApp::GetMacExitMenuItemId();
22907
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 {
22912 resultobj = SWIG_From_long((long)(result));
22913 }
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj;
22922 wxString result;
22923 char *kwnames[] = {
22924 NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22928 {
22929 PyThreadState* __tstate = wxPyBeginAllowThreads();
22930 result = wxPyApp::GetMacHelpMenuTitleName();
22931
22932 wxPyEndAllowThreads(__tstate);
22933 if (PyErr_Occurred()) SWIG_fail;
22934 }
22935 {
22936 #if wxUSE_UNICODE
22937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22938 #else
22939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22940 #endif
22941 }
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj;
22950 bool arg1 ;
22951 PyObject * obj0 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "val", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22957 {
22958 arg1 = (bool)(SWIG_As_bool(obj0));
22959 if (SWIG_arg_fail(1)) SWIG_fail;
22960 }
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22964
22965 wxPyEndAllowThreads(__tstate);
22966 if (PyErr_Occurred()) SWIG_fail;
22967 }
22968 Py_INCREF(Py_None); resultobj = Py_None;
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22976 PyObject *resultobj;
22977 long arg1 ;
22978 PyObject * obj0 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "val", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22984 {
22985 arg1 = (long)(SWIG_As_long(obj0));
22986 if (SWIG_arg_fail(1)) SWIG_fail;
22987 }
22988 {
22989 PyThreadState* __tstate = wxPyBeginAllowThreads();
22990 wxPyApp::SetMacAboutMenuItemId(arg1);
22991
22992 wxPyEndAllowThreads(__tstate);
22993 if (PyErr_Occurred()) SWIG_fail;
22994 }
22995 Py_INCREF(Py_None); resultobj = Py_None;
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23003 PyObject *resultobj;
23004 long arg1 ;
23005 PyObject * obj0 = 0 ;
23006 char *kwnames[] = {
23007 (char *) "val", NULL
23008 };
23009
23010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23011 {
23012 arg1 = (long)(SWIG_As_long(obj0));
23013 if (SWIG_arg_fail(1)) SWIG_fail;
23014 }
23015 {
23016 PyThreadState* __tstate = wxPyBeginAllowThreads();
23017 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23018
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 Py_INCREF(Py_None); resultobj = Py_None;
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj;
23031 long arg1 ;
23032 PyObject * obj0 = 0 ;
23033 char *kwnames[] = {
23034 (char *) "val", NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23038 {
23039 arg1 = (long)(SWIG_As_long(obj0));
23040 if (SWIG_arg_fail(1)) SWIG_fail;
23041 }
23042 {
23043 PyThreadState* __tstate = wxPyBeginAllowThreads();
23044 wxPyApp::SetMacExitMenuItemId(arg1);
23045
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 Py_INCREF(Py_None); resultobj = Py_None;
23050 return resultobj;
23051 fail:
23052 return NULL;
23053 }
23054
23055
23056 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23057 PyObject *resultobj;
23058 wxString *arg1 = 0 ;
23059 bool temp1 = false ;
23060 PyObject * obj0 = 0 ;
23061 char *kwnames[] = {
23062 (char *) "val", NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23066 {
23067 arg1 = wxString_in_helper(obj0);
23068 if (arg1 == NULL) SWIG_fail;
23069 temp1 = true;
23070 }
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23074
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 Py_INCREF(Py_None); resultobj = Py_None;
23079 {
23080 if (temp1)
23081 delete arg1;
23082 }
23083 return resultobj;
23084 fail:
23085 {
23086 if (temp1)
23087 delete arg1;
23088 }
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxPyApp *arg1 = (wxPyApp *) 0 ;
23096 PyObject * obj0 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 (arg1)->_BootstrapApp();
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 Py_INCREF(Py_None); resultobj = Py_None;
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23119 PyObject *resultobj;
23120 int result;
23121 char *kwnames[] = {
23122 NULL
23123 };
23124
23125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (int)wxPyApp::GetComCtl32Version();
23129
23130 wxPyEndAllowThreads(__tstate);
23131 if (PyErr_Occurred()) SWIG_fail;
23132 }
23133 {
23134 resultobj = SWIG_From_int((int)(result));
23135 }
23136 return resultobj;
23137 fail:
23138 return NULL;
23139 }
23140
23141
23142 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23143 PyObject *obj;
23144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23145 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23146 Py_INCREF(obj);
23147 return Py_BuildValue((char *)"");
23148 }
23149 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23150 PyObject *resultobj;
23151 char *kwnames[] = {
23152 NULL
23153 };
23154
23155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 wxExit();
23159
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 Py_INCREF(Py_None); resultobj = Py_None;
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj;
23172 bool result;
23173 char *kwnames[] = {
23174 NULL
23175 };
23176
23177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 result = (bool)wxYield();
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 {
23186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23187 }
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj;
23196 bool result;
23197 char *kwnames[] = {
23198 NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)wxYieldIfNeeded();
23205
23206 wxPyEndAllowThreads(__tstate);
23207 if (PyErr_Occurred()) SWIG_fail;
23208 }
23209 {
23210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23211 }
23212 return resultobj;
23213 fail:
23214 return NULL;
23215 }
23216
23217
23218 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23219 PyObject *resultobj;
23220 wxWindow *arg1 = (wxWindow *) NULL ;
23221 bool arg2 = (bool) false ;
23222 bool result;
23223 PyObject * obj0 = 0 ;
23224 PyObject * obj1 = 0 ;
23225 char *kwnames[] = {
23226 (char *) "win",(char *) "onlyIfNeeded", NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23230 if (obj0) {
23231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23232 if (SWIG_arg_fail(1)) SWIG_fail;
23233 }
23234 if (obj1) {
23235 {
23236 arg2 = (bool)(SWIG_As_bool(obj1));
23237 if (SWIG_arg_fail(2)) SWIG_fail;
23238 }
23239 }
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = (bool)wxSafeYield(arg1,arg2);
23243
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 {
23248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23249 }
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj;
23258 char *kwnames[] = {
23259 NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 wxWakeUpIdle();
23266
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 Py_INCREF(Py_None); resultobj = Py_None;
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23278 PyObject *resultobj;
23279 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23280 wxEvent *arg2 = 0 ;
23281 PyObject * obj0 = 0 ;
23282 PyObject * obj1 = 0 ;
23283 char *kwnames[] = {
23284 (char *) "dest",(char *) "event", NULL
23285 };
23286
23287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(1)) SWIG_fail;
23290 {
23291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23292 if (SWIG_arg_fail(2)) SWIG_fail;
23293 if (arg2 == NULL) {
23294 SWIG_null_ref("wxEvent");
23295 }
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 }
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 wxPostEvent(arg1,*arg2);
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 Py_INCREF(Py_None); resultobj = Py_None;
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 char *kwnames[] = {
23315 NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 wxApp_CleanUp();
23322
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 Py_INCREF(Py_None); resultobj = Py_None;
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj;
23335 wxPyApp *result;
23336 char *kwnames[] = {
23337 NULL
23338 };
23339
23340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = (wxPyApp *)wxPyGetApp();
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 {
23349 resultobj = wxPyMake_wxObject(result, 0);
23350 }
23351 return resultobj;
23352 fail:
23353 return NULL;
23354 }
23355
23356
23357 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23358 PyObject *resultobj;
23359 char *arg1 = (char *) 0 ;
23360 PyObject * obj0 = 0 ;
23361 char *kwnames[] = {
23362 (char *) "encoding", NULL
23363 };
23364
23365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23366 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23367 SWIG_arg_fail(1);SWIG_fail;
23368 }
23369 {
23370 PyThreadState* __tstate = wxPyBeginAllowThreads();
23371 wxSetDefaultPyEncoding((char const *)arg1);
23372
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 Py_INCREF(Py_None); resultobj = Py_None;
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 char *result;
23386 char *kwnames[] = {
23387 NULL
23388 };
23389
23390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (char *)wxGetDefaultPyEncoding();
23394
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 resultobj = SWIG_FromCharPtr(result);
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj;
23407 wxEventLoop *result;
23408 char *kwnames[] = {
23409 NULL
23410 };
23411
23412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 result = (wxEventLoop *)new wxEventLoop();
23416
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23428 PyObject *resultobj;
23429 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23430 PyObject * obj0 = 0 ;
23431 char *kwnames[] = {
23432 (char *) "self", NULL
23433 };
23434
23435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23437 if (SWIG_arg_fail(1)) SWIG_fail;
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 delete arg1;
23441
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 Py_INCREF(Py_None); resultobj = Py_None;
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23453 PyObject *resultobj;
23454 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23455 int result;
23456 PyObject * obj0 = 0 ;
23457 char *kwnames[] = {
23458 (char *) "self", NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(1)) SWIG_fail;
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (int)(arg1)->Run();
23467
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 {
23472 resultobj = SWIG_From_int((int)(result));
23473 }
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23483 int arg2 = (int) 0 ;
23484 PyObject * obj0 = 0 ;
23485 PyObject * obj1 = 0 ;
23486 char *kwnames[] = {
23487 (char *) "self",(char *) "rc", NULL
23488 };
23489
23490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23492 if (SWIG_arg_fail(1)) SWIG_fail;
23493 if (obj1) {
23494 {
23495 arg2 = (int)(SWIG_As_int(obj1));
23496 if (SWIG_arg_fail(2)) SWIG_fail;
23497 }
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 (arg1)->Exit(arg2);
23502
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 Py_INCREF(Py_None); resultobj = Py_None;
23507 return resultobj;
23508 fail:
23509 return NULL;
23510 }
23511
23512
23513 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23514 PyObject *resultobj;
23515 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23516 bool result;
23517 PyObject * obj0 = 0 ;
23518 char *kwnames[] = {
23519 (char *) "self", NULL
23520 };
23521
23522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23524 if (SWIG_arg_fail(1)) SWIG_fail;
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (bool)((wxEventLoop const *)arg1)->Pending();
23528
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23542 PyObject *resultobj;
23543 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23544 bool result;
23545 PyObject * obj0 = 0 ;
23546 char *kwnames[] = {
23547 (char *) "self", NULL
23548 };
23549
23550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23552 if (SWIG_arg_fail(1)) SWIG_fail;
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = (bool)(arg1)->Dispatch();
23556
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 {
23561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23562 }
23563 return resultobj;
23564 fail:
23565 return NULL;
23566 }
23567
23568
23569 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23570 PyObject *resultobj;
23571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23572 bool result;
23573 PyObject * obj0 = 0 ;
23574 char *kwnames[] = {
23575 (char *) "self", NULL
23576 };
23577
23578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23580 if (SWIG_arg_fail(1)) SWIG_fail;
23581 {
23582 PyThreadState* __tstate = wxPyBeginAllowThreads();
23583 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23584
23585 wxPyEndAllowThreads(__tstate);
23586 if (PyErr_Occurred()) SWIG_fail;
23587 }
23588 {
23589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23590 }
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj;
23599 wxEventLoop *result;
23600 char *kwnames[] = {
23601 NULL
23602 };
23603
23604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = (wxEventLoop *)wxEventLoop::GetActive();
23608
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj;
23621 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23622 PyObject * obj0 = 0 ;
23623 char *kwnames[] = {
23624 (char *) "loop", NULL
23625 };
23626
23627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23629 if (SWIG_arg_fail(1)) SWIG_fail;
23630 {
23631 PyThreadState* __tstate = wxPyBeginAllowThreads();
23632 wxEventLoop::SetActive(arg1);
23633
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 Py_INCREF(Py_None); resultobj = Py_None;
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23645 PyObject *obj;
23646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23647 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23648 Py_INCREF(obj);
23649 return Py_BuildValue((char *)"");
23650 }
23651 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 int arg1 = (int) 0 ;
23654 int arg2 = (int) 0 ;
23655 int arg3 = (int) 0 ;
23656 wxAcceleratorEntry *result;
23657 PyObject * obj0 = 0 ;
23658 PyObject * obj1 = 0 ;
23659 PyObject * obj2 = 0 ;
23660 char *kwnames[] = {
23661 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23662 };
23663
23664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23665 if (obj0) {
23666 {
23667 arg1 = (int)(SWIG_As_int(obj0));
23668 if (SWIG_arg_fail(1)) SWIG_fail;
23669 }
23670 }
23671 if (obj1) {
23672 {
23673 arg2 = (int)(SWIG_As_int(obj1));
23674 if (SWIG_arg_fail(2)) SWIG_fail;
23675 }
23676 }
23677 if (obj2) {
23678 {
23679 arg3 = (int)(SWIG_As_int(obj2));
23680 if (SWIG_arg_fail(3)) SWIG_fail;
23681 }
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj;
23699 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23700 PyObject * obj0 = 0 ;
23701 char *kwnames[] = {
23702 (char *) "self", NULL
23703 };
23704
23705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23707 if (SWIG_arg_fail(1)) SWIG_fail;
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 delete arg1;
23711
23712 wxPyEndAllowThreads(__tstate);
23713 if (PyErr_Occurred()) SWIG_fail;
23714 }
23715 Py_INCREF(Py_None); resultobj = Py_None;
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23725 int arg2 ;
23726 int arg3 ;
23727 int arg4 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 PyObject * obj2 = 0 ;
23731 PyObject * obj3 = 0 ;
23732 char *kwnames[] = {
23733 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23734 };
23735
23736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23738 if (SWIG_arg_fail(1)) SWIG_fail;
23739 {
23740 arg2 = (int)(SWIG_As_int(obj1));
23741 if (SWIG_arg_fail(2)) SWIG_fail;
23742 }
23743 {
23744 arg3 = (int)(SWIG_As_int(obj2));
23745 if (SWIG_arg_fail(3)) SWIG_fail;
23746 }
23747 {
23748 arg4 = (int)(SWIG_As_int(obj3));
23749 if (SWIG_arg_fail(4)) SWIG_fail;
23750 }
23751 {
23752 PyThreadState* __tstate = wxPyBeginAllowThreads();
23753 (arg1)->Set(arg2,arg3,arg4);
23754
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 Py_INCREF(Py_None); resultobj = Py_None;
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23766 PyObject *resultobj;
23767 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23768 int result;
23769 PyObject * obj0 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "self", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23776 if (SWIG_arg_fail(1)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = (int)(arg1)->GetFlags();
23780
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 {
23785 resultobj = SWIG_From_int((int)(result));
23786 }
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23794 PyObject *resultobj;
23795 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23796 int result;
23797 PyObject * obj0 = 0 ;
23798 char *kwnames[] = {
23799 (char *) "self", NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 result = (int)(arg1)->GetKeyCode();
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 {
23813 resultobj = SWIG_From_int((int)(result));
23814 }
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23824 int result;
23825 PyObject * obj0 = 0 ;
23826 char *kwnames[] = {
23827 (char *) "self", NULL
23828 };
23829
23830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 result = (int)(arg1)->GetCommand();
23836
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 {
23841 resultobj = SWIG_From_int((int)(result));
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23850 PyObject *obj;
23851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23852 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23853 Py_INCREF(obj);
23854 return Py_BuildValue((char *)"");
23855 }
23856 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 int arg1 ;
23859 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23860 wxAcceleratorTable *result;
23861 PyObject * obj0 = 0 ;
23862 char *kwnames[] = {
23863 (char *) "n", NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23867 {
23868 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23869 if (arg2) arg1 = PyList_Size(obj0);
23870 else arg1 = 0;
23871 }
23872 {
23873 PyThreadState* __tstate = wxPyBeginAllowThreads();
23874 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23875
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23880 {
23881 delete [] arg2;
23882 }
23883 return resultobj;
23884 fail:
23885 {
23886 delete [] arg2;
23887 }
23888 return NULL;
23889 }
23890
23891
23892 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj;
23894 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23895 PyObject * obj0 = 0 ;
23896 char *kwnames[] = {
23897 (char *) "self", NULL
23898 };
23899
23900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23902 if (SWIG_arg_fail(1)) SWIG_fail;
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 delete arg1;
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 Py_INCREF(Py_None); resultobj = Py_None;
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23918 PyObject *resultobj;
23919 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23920 bool result;
23921 PyObject * obj0 = 0 ;
23922 char *kwnames[] = {
23923 (char *) "self", NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23928 if (SWIG_arg_fail(1)) SWIG_fail;
23929 {
23930 PyThreadState* __tstate = wxPyBeginAllowThreads();
23931 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23932
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23946 PyObject *obj;
23947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23948 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23949 Py_INCREF(obj);
23950 return Py_BuildValue((char *)"");
23951 }
23952 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23953 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23954 return 1;
23955 }
23956
23957
23958 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23959 PyObject *pyobj;
23960
23961 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23962 return pyobj;
23963 }
23964
23965
23966 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj;
23968 wxString *arg1 = 0 ;
23969 wxAcceleratorEntry *result;
23970 bool temp1 = false ;
23971 PyObject * obj0 = 0 ;
23972 char *kwnames[] = {
23973 (char *) "label", NULL
23974 };
23975
23976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23977 {
23978 arg1 = wxString_in_helper(obj0);
23979 if (arg1 == NULL) SWIG_fail;
23980 temp1 = true;
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23985
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23990 {
23991 if (temp1)
23992 delete arg1;
23993 }
23994 return resultobj;
23995 fail:
23996 {
23997 if (temp1)
23998 delete arg1;
23999 }
24000 return NULL;
24001 }
24002
24003
24004 static int _wrap_PanelNameStr_set(PyObject *) {
24005 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24006 return 1;
24007 }
24008
24009
24010 static PyObject *_wrap_PanelNameStr_get(void) {
24011 PyObject *pyobj;
24012
24013 {
24014 #if wxUSE_UNICODE
24015 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24016 #else
24017 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24018 #endif
24019 }
24020 return pyobj;
24021 }
24022
24023
24024 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj;
24026 wxVisualAttributes *result;
24027 char *kwnames[] = {
24028 NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 result = (wxVisualAttributes *)new_wxVisualAttributes();
24035
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24047 PyObject *resultobj;
24048 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24049 PyObject * obj0 = 0 ;
24050 char *kwnames[] = {
24051 (char *) "self", NULL
24052 };
24053
24054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24056 if (SWIG_arg_fail(1)) SWIG_fail;
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 delete_wxVisualAttributes(arg1);
24060
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 Py_INCREF(Py_None); resultobj = Py_None;
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj;
24073 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24074 wxFont *arg2 = (wxFont *) 0 ;
24075 PyObject * obj0 = 0 ;
24076 PyObject * obj1 = 0 ;
24077 char *kwnames[] = {
24078 (char *) "self",(char *) "font", NULL
24079 };
24080
24081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24083 if (SWIG_arg_fail(1)) SWIG_fail;
24084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(2)) SWIG_fail;
24086 if (arg1) (arg1)->font = *arg2;
24087
24088 Py_INCREF(Py_None); resultobj = Py_None;
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24098 wxFont *result;
24099 PyObject * obj0 = 0 ;
24100 char *kwnames[] = {
24101 (char *) "self", NULL
24102 };
24103
24104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24106 if (SWIG_arg_fail(1)) SWIG_fail;
24107 result = (wxFont *)& ((arg1)->font);
24108
24109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24119 wxColour *arg2 = (wxColour *) 0 ;
24120 PyObject * obj0 = 0 ;
24121 PyObject * obj1 = 0 ;
24122 char *kwnames[] = {
24123 (char *) "self",(char *) "colFg", NULL
24124 };
24125
24126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(1)) SWIG_fail;
24129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(2)) SWIG_fail;
24131 if (arg1) (arg1)->colFg = *arg2;
24132
24133 Py_INCREF(Py_None); resultobj = Py_None;
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24143 wxColour *result;
24144 PyObject * obj0 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "self", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 result = (wxColour *)& ((arg1)->colFg);
24153
24154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24155 return resultobj;
24156 fail:
24157 return NULL;
24158 }
24159
24160
24161 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24162 PyObject *resultobj;
24163 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24164 wxColour *arg2 = (wxColour *) 0 ;
24165 PyObject * obj0 = 0 ;
24166 PyObject * obj1 = 0 ;
24167 char *kwnames[] = {
24168 (char *) "self",(char *) "colBg", NULL
24169 };
24170
24171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24173 if (SWIG_arg_fail(1)) SWIG_fail;
24174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(2)) SWIG_fail;
24176 if (arg1) (arg1)->colBg = *arg2;
24177
24178 Py_INCREF(Py_None); resultobj = Py_None;
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj;
24187 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24188 wxColour *result;
24189 PyObject * obj0 = 0 ;
24190 char *kwnames[] = {
24191 (char *) "self", NULL
24192 };
24193
24194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24196 if (SWIG_arg_fail(1)) SWIG_fail;
24197 result = (wxColour *)& ((arg1)->colBg);
24198
24199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24207 PyObject *obj;
24208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24209 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24210 Py_INCREF(obj);
24211 return Py_BuildValue((char *)"");
24212 }
24213 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24214 PyObject *resultobj;
24215 wxWindow *arg1 = (wxWindow *) 0 ;
24216 int arg2 = (int) (int)-1 ;
24217 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24218 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24219 wxSize const &arg4_defvalue = wxDefaultSize ;
24220 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24221 long arg5 = (long) 0 ;
24222 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24223 wxString *arg6 = (wxString *) &arg6_defvalue ;
24224 wxWindow *result;
24225 wxPoint temp3 ;
24226 wxSize temp4 ;
24227 bool temp6 = false ;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230 PyObject * obj2 = 0 ;
24231 PyObject * obj3 = 0 ;
24232 PyObject * obj4 = 0 ;
24233 PyObject * obj5 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24240 if (SWIG_arg_fail(1)) SWIG_fail;
24241 if (obj1) {
24242 {
24243 arg2 = (int const)(SWIG_As_int(obj1));
24244 if (SWIG_arg_fail(2)) SWIG_fail;
24245 }
24246 }
24247 if (obj2) {
24248 {
24249 arg3 = &temp3;
24250 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24251 }
24252 }
24253 if (obj3) {
24254 {
24255 arg4 = &temp4;
24256 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24257 }
24258 }
24259 if (obj4) {
24260 {
24261 arg5 = (long)(SWIG_As_long(obj4));
24262 if (SWIG_arg_fail(5)) SWIG_fail;
24263 }
24264 }
24265 if (obj5) {
24266 {
24267 arg6 = wxString_in_helper(obj5);
24268 if (arg6 == NULL) SWIG_fail;
24269 temp6 = true;
24270 }
24271 }
24272 {
24273 if (!wxPyCheckForApp()) SWIG_fail;
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24276
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24281 {
24282 if (temp6)
24283 delete arg6;
24284 }
24285 return resultobj;
24286 fail:
24287 {
24288 if (temp6)
24289 delete arg6;
24290 }
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxWindow *result;
24298 char *kwnames[] = {
24299 NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24303 {
24304 if (!wxPyCheckForApp()) SWIG_fail;
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 result = (wxWindow *)new wxWindow();
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj;
24320 wxWindow *arg1 = (wxWindow *) 0 ;
24321 wxWindow *arg2 = (wxWindow *) 0 ;
24322 int arg3 = (int) (int)-1 ;
24323 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24324 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24325 wxSize const &arg5_defvalue = wxDefaultSize ;
24326 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24327 long arg6 = (long) 0 ;
24328 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24329 wxString *arg7 = (wxString *) &arg7_defvalue ;
24330 bool result;
24331 wxPoint temp4 ;
24332 wxSize temp5 ;
24333 bool temp7 = false ;
24334 PyObject * obj0 = 0 ;
24335 PyObject * obj1 = 0 ;
24336 PyObject * obj2 = 0 ;
24337 PyObject * obj3 = 0 ;
24338 PyObject * obj4 = 0 ;
24339 PyObject * obj5 = 0 ;
24340 PyObject * obj6 = 0 ;
24341 char *kwnames[] = {
24342 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24343 };
24344
24345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24347 if (SWIG_arg_fail(1)) SWIG_fail;
24348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24349 if (SWIG_arg_fail(2)) SWIG_fail;
24350 if (obj2) {
24351 {
24352 arg3 = (int const)(SWIG_As_int(obj2));
24353 if (SWIG_arg_fail(3)) SWIG_fail;
24354 }
24355 }
24356 if (obj3) {
24357 {
24358 arg4 = &temp4;
24359 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24360 }
24361 }
24362 if (obj4) {
24363 {
24364 arg5 = &temp5;
24365 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24366 }
24367 }
24368 if (obj5) {
24369 {
24370 arg6 = (long)(SWIG_As_long(obj5));
24371 if (SWIG_arg_fail(6)) SWIG_fail;
24372 }
24373 }
24374 if (obj6) {
24375 {
24376 arg7 = wxString_in_helper(obj6);
24377 if (arg7 == NULL) SWIG_fail;
24378 temp7 = true;
24379 }
24380 }
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24384
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 {
24389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24390 }
24391 {
24392 if (temp7)
24393 delete arg7;
24394 }
24395 return resultobj;
24396 fail:
24397 {
24398 if (temp7)
24399 delete arg7;
24400 }
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxWindow *arg1 = (wxWindow *) 0 ;
24408 bool arg2 = (bool) false ;
24409 bool result;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self",(char *) "force", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 if (obj1) {
24420 {
24421 arg2 = (bool)(SWIG_As_bool(obj1));
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (bool)(arg1)->Close(arg2);
24428
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 {
24433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24434 }
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24442 PyObject *resultobj;
24443 wxWindow *arg1 = (wxWindow *) 0 ;
24444 bool result;
24445 PyObject * obj0 = 0 ;
24446 char *kwnames[] = {
24447 (char *) "self", NULL
24448 };
24449
24450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24452 if (SWIG_arg_fail(1)) SWIG_fail;
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 result = (bool)(arg1)->Destroy();
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 {
24461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24462 }
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj;
24471 wxWindow *arg1 = (wxWindow *) 0 ;
24472 bool result;
24473 PyObject * obj0 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 result = (bool)(arg1)->DestroyChildren();
24484
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 {
24489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24490 }
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24498 PyObject *resultobj;
24499 wxWindow *arg1 = (wxWindow *) 0 ;
24500 bool result;
24501 PyObject * obj0 = 0 ;
24502 char *kwnames[] = {
24503 (char *) "self", NULL
24504 };
24505
24506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(1)) SWIG_fail;
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24512
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 {
24517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24518 }
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24526 PyObject *resultobj;
24527 wxWindow *arg1 = (wxWindow *) 0 ;
24528 wxString *arg2 = 0 ;
24529 bool temp2 = false ;
24530 PyObject * obj0 = 0 ;
24531 PyObject * obj1 = 0 ;
24532 char *kwnames[] = {
24533 (char *) "self",(char *) "title", NULL
24534 };
24535
24536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24538 if (SWIG_arg_fail(1)) SWIG_fail;
24539 {
24540 arg2 = wxString_in_helper(obj1);
24541 if (arg2 == NULL) SWIG_fail;
24542 temp2 = true;
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 (arg1)->SetTitle((wxString const &)*arg2);
24547
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 Py_INCREF(Py_None); resultobj = Py_None;
24552 {
24553 if (temp2)
24554 delete arg2;
24555 }
24556 return resultobj;
24557 fail:
24558 {
24559 if (temp2)
24560 delete arg2;
24561 }
24562 return NULL;
24563 }
24564
24565
24566 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj;
24568 wxWindow *arg1 = (wxWindow *) 0 ;
24569 wxString result;
24570 PyObject * obj0 = 0 ;
24571 char *kwnames[] = {
24572 (char *) "self", NULL
24573 };
24574
24575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24577 if (SWIG_arg_fail(1)) SWIG_fail;
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 result = ((wxWindow const *)arg1)->GetTitle();
24581
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 {
24586 #if wxUSE_UNICODE
24587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24588 #else
24589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24590 #endif
24591 }
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24599 PyObject *resultobj;
24600 wxWindow *arg1 = (wxWindow *) 0 ;
24601 wxString *arg2 = 0 ;
24602 bool temp2 = false ;
24603 PyObject * obj0 = 0 ;
24604 PyObject * obj1 = 0 ;
24605 char *kwnames[] = {
24606 (char *) "self",(char *) "label", NULL
24607 };
24608
24609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24611 if (SWIG_arg_fail(1)) SWIG_fail;
24612 {
24613 arg2 = wxString_in_helper(obj1);
24614 if (arg2 == NULL) SWIG_fail;
24615 temp2 = true;
24616 }
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 (arg1)->SetLabel((wxString const &)*arg2);
24620
24621 wxPyEndAllowThreads(__tstate);
24622 if (PyErr_Occurred()) SWIG_fail;
24623 }
24624 Py_INCREF(Py_None); resultobj = Py_None;
24625 {
24626 if (temp2)
24627 delete arg2;
24628 }
24629 return resultobj;
24630 fail:
24631 {
24632 if (temp2)
24633 delete arg2;
24634 }
24635 return NULL;
24636 }
24637
24638
24639 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 wxWindow *arg1 = (wxWindow *) 0 ;
24642 wxString result;
24643 PyObject * obj0 = 0 ;
24644 char *kwnames[] = {
24645 (char *) "self", NULL
24646 };
24647
24648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24650 if (SWIG_arg_fail(1)) SWIG_fail;
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 result = ((wxWindow const *)arg1)->GetLabel();
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 {
24659 #if wxUSE_UNICODE
24660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24661 #else
24662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24663 #endif
24664 }
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj;
24673 wxWindow *arg1 = (wxWindow *) 0 ;
24674 wxString *arg2 = 0 ;
24675 bool temp2 = false ;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "self",(char *) "name", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(1)) SWIG_fail;
24685 {
24686 arg2 = wxString_in_helper(obj1);
24687 if (arg2 == NULL) SWIG_fail;
24688 temp2 = true;
24689 }
24690 {
24691 PyThreadState* __tstate = wxPyBeginAllowThreads();
24692 (arg1)->SetName((wxString const &)*arg2);
24693
24694 wxPyEndAllowThreads(__tstate);
24695 if (PyErr_Occurred()) SWIG_fail;
24696 }
24697 Py_INCREF(Py_None); resultobj = Py_None;
24698 {
24699 if (temp2)
24700 delete arg2;
24701 }
24702 return resultobj;
24703 fail:
24704 {
24705 if (temp2)
24706 delete arg2;
24707 }
24708 return NULL;
24709 }
24710
24711
24712 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24713 PyObject *resultobj;
24714 wxWindow *arg1 = (wxWindow *) 0 ;
24715 wxString result;
24716 PyObject * obj0 = 0 ;
24717 char *kwnames[] = {
24718 (char *) "self", NULL
24719 };
24720
24721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24723 if (SWIG_arg_fail(1)) SWIG_fail;
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = ((wxWindow const *)arg1)->GetName();
24727
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 #if wxUSE_UNICODE
24733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24734 #else
24735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24736 #endif
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj;
24746 wxWindow *arg1 = (wxWindow *) 0 ;
24747 wxWindowVariant arg2 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char *kwnames[] = {
24751 (char *) "self",(char *) "variant", NULL
24752 };
24753
24754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24756 if (SWIG_arg_fail(1)) SWIG_fail;
24757 {
24758 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24759 if (SWIG_arg_fail(2)) SWIG_fail;
24760 }
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24764
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 Py_INCREF(Py_None); resultobj = Py_None;
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxWindow *arg1 = (wxWindow *) 0 ;
24778 wxWindowVariant result;
24779 PyObject * obj0 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 resultobj = SWIG_From_int((result));
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj;
24803 wxWindow *arg1 = (wxWindow *) 0 ;
24804 int arg2 ;
24805 PyObject * obj0 = 0 ;
24806 PyObject * obj1 = 0 ;
24807 char *kwnames[] = {
24808 (char *) "self",(char *) "winid", NULL
24809 };
24810
24811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24813 if (SWIG_arg_fail(1)) SWIG_fail;
24814 {
24815 arg2 = (int)(SWIG_As_int(obj1));
24816 if (SWIG_arg_fail(2)) SWIG_fail;
24817 }
24818 {
24819 PyThreadState* __tstate = wxPyBeginAllowThreads();
24820 (arg1)->SetId(arg2);
24821
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 Py_INCREF(Py_None); resultobj = Py_None;
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj;
24834 wxWindow *arg1 = (wxWindow *) 0 ;
24835 int result;
24836 PyObject * obj0 = 0 ;
24837 char *kwnames[] = {
24838 (char *) "self", NULL
24839 };
24840
24841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24843 if (SWIG_arg_fail(1)) SWIG_fail;
24844 {
24845 PyThreadState* __tstate = wxPyBeginAllowThreads();
24846 result = (int)((wxWindow const *)arg1)->GetId();
24847
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 {
24852 resultobj = SWIG_From_int((int)(result));
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24861 PyObject *resultobj;
24862 int result;
24863 char *kwnames[] = {
24864 NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = (int)wxWindow::NewControlId();
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 resultobj = SWIG_From_int((int)(result));
24877 }
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24885 PyObject *resultobj;
24886 int arg1 ;
24887 int result;
24888 PyObject * obj0 = 0 ;
24889 char *kwnames[] = {
24890 (char *) "winid", NULL
24891 };
24892
24893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24894 {
24895 arg1 = (int)(SWIG_As_int(obj0));
24896 if (SWIG_arg_fail(1)) SWIG_fail;
24897 }
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = (int)wxWindow::NextControlId(arg1);
24901
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 {
24906 resultobj = SWIG_From_int((int)(result));
24907 }
24908 return resultobj;
24909 fail:
24910 return NULL;
24911 }
24912
24913
24914 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj;
24916 int arg1 ;
24917 int result;
24918 PyObject * obj0 = 0 ;
24919 char *kwnames[] = {
24920 (char *) "winid", NULL
24921 };
24922
24923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24924 {
24925 arg1 = (int)(SWIG_As_int(obj0));
24926 if (SWIG_arg_fail(1)) SWIG_fail;
24927 }
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (int)wxWindow::PrevControlId(arg1);
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = SWIG_From_int((int)(result));
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxWindow *arg1 = (wxWindow *) 0 ;
24947 wxSize *arg2 = 0 ;
24948 wxSize temp2 ;
24949 PyObject * obj0 = 0 ;
24950 PyObject * obj1 = 0 ;
24951 char *kwnames[] = {
24952 (char *) "self",(char *) "size", NULL
24953 };
24954
24955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24957 if (SWIG_arg_fail(1)) SWIG_fail;
24958 {
24959 arg2 = &temp2;
24960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24961 }
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 (arg1)->SetSize((wxSize const &)*arg2);
24965
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 Py_INCREF(Py_None); resultobj = Py_None;
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj;
24978 wxWindow *arg1 = (wxWindow *) 0 ;
24979 int arg2 ;
24980 int arg3 ;
24981 int arg4 ;
24982 int arg5 ;
24983 int arg6 = (int) wxSIZE_AUTO ;
24984 PyObject * obj0 = 0 ;
24985 PyObject * obj1 = 0 ;
24986 PyObject * obj2 = 0 ;
24987 PyObject * obj3 = 0 ;
24988 PyObject * obj4 = 0 ;
24989 PyObject * obj5 = 0 ;
24990 char *kwnames[] = {
24991 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24992 };
24993
24994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24996 if (SWIG_arg_fail(1)) SWIG_fail;
24997 {
24998 arg2 = (int)(SWIG_As_int(obj1));
24999 if (SWIG_arg_fail(2)) SWIG_fail;
25000 }
25001 {
25002 arg3 = (int)(SWIG_As_int(obj2));
25003 if (SWIG_arg_fail(3)) SWIG_fail;
25004 }
25005 {
25006 arg4 = (int)(SWIG_As_int(obj3));
25007 if (SWIG_arg_fail(4)) SWIG_fail;
25008 }
25009 {
25010 arg5 = (int)(SWIG_As_int(obj4));
25011 if (SWIG_arg_fail(5)) SWIG_fail;
25012 }
25013 if (obj5) {
25014 {
25015 arg6 = (int)(SWIG_As_int(obj5));
25016 if (SWIG_arg_fail(6)) SWIG_fail;
25017 }
25018 }
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25022
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 Py_INCREF(Py_None); resultobj = Py_None;
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25034 PyObject *resultobj;
25035 wxWindow *arg1 = (wxWindow *) 0 ;
25036 wxRect *arg2 = 0 ;
25037 int arg3 = (int) wxSIZE_AUTO ;
25038 wxRect temp2 ;
25039 PyObject * obj0 = 0 ;
25040 PyObject * obj1 = 0 ;
25041 PyObject * obj2 = 0 ;
25042 char *kwnames[] = {
25043 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25044 };
25045
25046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25048 if (SWIG_arg_fail(1)) SWIG_fail;
25049 {
25050 arg2 = &temp2;
25051 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25052 }
25053 if (obj2) {
25054 {
25055 arg3 = (int)(SWIG_As_int(obj2));
25056 if (SWIG_arg_fail(3)) SWIG_fail;
25057 }
25058 }
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 Py_INCREF(Py_None); resultobj = Py_None;
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj;
25075 wxWindow *arg1 = (wxWindow *) 0 ;
25076 int arg2 ;
25077 int arg3 ;
25078 PyObject * obj0 = 0 ;
25079 PyObject * obj1 = 0 ;
25080 PyObject * obj2 = 0 ;
25081 char *kwnames[] = {
25082 (char *) "self",(char *) "width",(char *) "height", NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25087 if (SWIG_arg_fail(1)) SWIG_fail;
25088 {
25089 arg2 = (int)(SWIG_As_int(obj1));
25090 if (SWIG_arg_fail(2)) SWIG_fail;
25091 }
25092 {
25093 arg3 = (int)(SWIG_As_int(obj2));
25094 if (SWIG_arg_fail(3)) SWIG_fail;
25095 }
25096 {
25097 PyThreadState* __tstate = wxPyBeginAllowThreads();
25098 (arg1)->SetSize(arg2,arg3);
25099
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 Py_INCREF(Py_None); resultobj = Py_None;
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj;
25112 wxWindow *arg1 = (wxWindow *) 0 ;
25113 wxPoint *arg2 = 0 ;
25114 int arg3 = (int) wxSIZE_USE_EXISTING ;
25115 wxPoint temp2 ;
25116 PyObject * obj0 = 0 ;
25117 PyObject * obj1 = 0 ;
25118 PyObject * obj2 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self",(char *) "pt",(char *) "flags", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 arg2 = &temp2;
25128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25129 }
25130 if (obj2) {
25131 {
25132 arg3 = (int)(SWIG_As_int(obj2));
25133 if (SWIG_arg_fail(3)) SWIG_fail;
25134 }
25135 }
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 (arg1)->Move((wxPoint const &)*arg2,arg3);
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 Py_INCREF(Py_None); resultobj = Py_None;
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj;
25152 wxWindow *arg1 = (wxWindow *) 0 ;
25153 int arg2 ;
25154 int arg3 ;
25155 int arg4 = (int) wxSIZE_USE_EXISTING ;
25156 PyObject * obj0 = 0 ;
25157 PyObject * obj1 = 0 ;
25158 PyObject * obj2 = 0 ;
25159 PyObject * obj3 = 0 ;
25160 char *kwnames[] = {
25161 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25162 };
25163
25164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25166 if (SWIG_arg_fail(1)) SWIG_fail;
25167 {
25168 arg2 = (int)(SWIG_As_int(obj1));
25169 if (SWIG_arg_fail(2)) SWIG_fail;
25170 }
25171 {
25172 arg3 = (int)(SWIG_As_int(obj2));
25173 if (SWIG_arg_fail(3)) SWIG_fail;
25174 }
25175 if (obj3) {
25176 {
25177 arg4 = (int)(SWIG_As_int(obj3));
25178 if (SWIG_arg_fail(4)) SWIG_fail;
25179 }
25180 }
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 (arg1)->Move(arg2,arg3,arg4);
25184
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 Py_INCREF(Py_None); resultobj = Py_None;
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxWindow *arg1 = (wxWindow *) 0 ;
25198 wxSize const &arg2_defvalue = wxDefaultSize ;
25199 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25200 wxSize temp2 ;
25201 PyObject * obj0 = 0 ;
25202 PyObject * obj1 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self",(char *) "size", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 if (obj1) {
25211 {
25212 arg2 = &temp2;
25213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25214 }
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 Py_INCREF(Py_None); resultobj = Py_None;
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25231 PyObject *resultobj;
25232 wxWindow *arg1 = (wxWindow *) 0 ;
25233 PyObject * obj0 = 0 ;
25234 char *kwnames[] = {
25235 (char *) "self", NULL
25236 };
25237
25238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25240 if (SWIG_arg_fail(1)) SWIG_fail;
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 (arg1)->Raise();
25244
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 Py_INCREF(Py_None); resultobj = Py_None;
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj;
25257 wxWindow *arg1 = (wxWindow *) 0 ;
25258 PyObject * obj0 = 0 ;
25259 char *kwnames[] = {
25260 (char *) "self", NULL
25261 };
25262
25263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25265 if (SWIG_arg_fail(1)) SWIG_fail;
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->Lower();
25269
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 Py_INCREF(Py_None); resultobj = Py_None;
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 wxSize *arg2 = 0 ;
25284 wxSize temp2 ;
25285 PyObject * obj0 = 0 ;
25286 PyObject * obj1 = 0 ;
25287 char *kwnames[] = {
25288 (char *) "self",(char *) "size", NULL
25289 };
25290
25291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25293 if (SWIG_arg_fail(1)) SWIG_fail;
25294 {
25295 arg2 = &temp2;
25296 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25297 }
25298 {
25299 PyThreadState* __tstate = wxPyBeginAllowThreads();
25300 (arg1)->SetClientSize((wxSize const &)*arg2);
25301
25302 wxPyEndAllowThreads(__tstate);
25303 if (PyErr_Occurred()) SWIG_fail;
25304 }
25305 Py_INCREF(Py_None); resultobj = Py_None;
25306 return resultobj;
25307 fail:
25308 return NULL;
25309 }
25310
25311
25312 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25313 PyObject *resultobj;
25314 wxWindow *arg1 = (wxWindow *) 0 ;
25315 int arg2 ;
25316 int arg3 ;
25317 PyObject * obj0 = 0 ;
25318 PyObject * obj1 = 0 ;
25319 PyObject * obj2 = 0 ;
25320 char *kwnames[] = {
25321 (char *) "self",(char *) "width",(char *) "height", NULL
25322 };
25323
25324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25326 if (SWIG_arg_fail(1)) SWIG_fail;
25327 {
25328 arg2 = (int)(SWIG_As_int(obj1));
25329 if (SWIG_arg_fail(2)) SWIG_fail;
25330 }
25331 {
25332 arg3 = (int)(SWIG_As_int(obj2));
25333 if (SWIG_arg_fail(3)) SWIG_fail;
25334 }
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 (arg1)->SetClientSize(arg2,arg3);
25338
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 Py_INCREF(Py_None); resultobj = Py_None;
25343 return resultobj;
25344 fail:
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxWindow *arg1 = (wxWindow *) 0 ;
25352 wxRect *arg2 = 0 ;
25353 wxRect temp2 ;
25354 PyObject * obj0 = 0 ;
25355 PyObject * obj1 = 0 ;
25356 char *kwnames[] = {
25357 (char *) "self",(char *) "rect", NULL
25358 };
25359
25360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25362 if (SWIG_arg_fail(1)) SWIG_fail;
25363 {
25364 arg2 = &temp2;
25365 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25366 }
25367 {
25368 PyThreadState* __tstate = wxPyBeginAllowThreads();
25369 (arg1)->SetClientSize((wxRect const &)*arg2);
25370
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 Py_INCREF(Py_None); resultobj = Py_None;
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 wxPoint result;
25385 PyObject * obj0 = 0 ;
25386 char *kwnames[] = {
25387 (char *) "self", NULL
25388 };
25389
25390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25392 if (SWIG_arg_fail(1)) SWIG_fail;
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 result = (arg1)->GetPosition();
25396
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 {
25401 wxPoint * resultptr;
25402 resultptr = new wxPoint((wxPoint &)(result));
25403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25404 }
25405 return resultobj;
25406 fail:
25407 return NULL;
25408 }
25409
25410
25411 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25412 PyObject *resultobj;
25413 wxWindow *arg1 = (wxWindow *) 0 ;
25414 int *arg2 = (int *) 0 ;
25415 int *arg3 = (int *) 0 ;
25416 int temp2 ;
25417 int res2 = 0 ;
25418 int temp3 ;
25419 int res3 = 0 ;
25420 PyObject * obj0 = 0 ;
25421 char *kwnames[] = {
25422 (char *) "self", NULL
25423 };
25424
25425 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25426 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",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 (arg1)->GetPosition(arg2,arg3);
25433
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 Py_INCREF(Py_None); resultobj = Py_None;
25438 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25439 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25440 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25441 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj;
25450 wxWindow *arg1 = (wxWindow *) 0 ;
25451 wxSize result;
25452 PyObject * obj0 = 0 ;
25453 char *kwnames[] = {
25454 (char *) "self", NULL
25455 };
25456
25457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25459 if (SWIG_arg_fail(1)) SWIG_fail;
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = ((wxWindow const *)arg1)->GetSize();
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 {
25468 wxSize * resultptr;
25469 resultptr = new wxSize((wxSize &)(result));
25470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25471 }
25472 return resultobj;
25473 fail:
25474 return NULL;
25475 }
25476
25477
25478 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj;
25480 wxWindow *arg1 = (wxWindow *) 0 ;
25481 int *arg2 = (int *) 0 ;
25482 int *arg3 = (int *) 0 ;
25483 int temp2 ;
25484 int res2 = 0 ;
25485 int temp3 ;
25486 int res3 = 0 ;
25487 PyObject * obj0 = 0 ;
25488 char *kwnames[] = {
25489 (char *) "self", NULL
25490 };
25491
25492 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25493 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25496 if (SWIG_arg_fail(1)) SWIG_fail;
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25500
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 Py_INCREF(Py_None); resultobj = Py_None;
25505 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25506 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25507 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25508 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25509 return resultobj;
25510 fail:
25511 return NULL;
25512 }
25513
25514
25515 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25516 PyObject *resultobj;
25517 wxWindow *arg1 = (wxWindow *) 0 ;
25518 wxRect result;
25519 PyObject * obj0 = 0 ;
25520 char *kwnames[] = {
25521 (char *) "self", NULL
25522 };
25523
25524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25526 if (SWIG_arg_fail(1)) SWIG_fail;
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = ((wxWindow const *)arg1)->GetRect();
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 {
25535 wxRect * resultptr;
25536 resultptr = new wxRect((wxRect &)(result));
25537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25538 }
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25546 PyObject *resultobj;
25547 wxWindow *arg1 = (wxWindow *) 0 ;
25548 wxSize result;
25549 PyObject * obj0 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = ((wxWindow const *)arg1)->GetClientSize();
25560
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 {
25565 wxSize * resultptr;
25566 resultptr = new wxSize((wxSize &)(result));
25567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25568 }
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25576 PyObject *resultobj;
25577 wxWindow *arg1 = (wxWindow *) 0 ;
25578 int *arg2 = (int *) 0 ;
25579 int *arg3 = (int *) 0 ;
25580 int temp2 ;
25581 int res2 = 0 ;
25582 int temp3 ;
25583 int res3 = 0 ;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25590 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25593 if (SWIG_arg_fail(1)) SWIG_fail;
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25597
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 Py_INCREF(Py_None); resultobj = Py_None;
25602 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25603 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25604 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25605 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj;
25614 wxWindow *arg1 = (wxWindow *) 0 ;
25615 wxPoint result;
25616 PyObject * obj0 = 0 ;
25617 char *kwnames[] = {
25618 (char *) "self", NULL
25619 };
25620
25621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25623 if (SWIG_arg_fail(1)) SWIG_fail;
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25627
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 {
25632 wxPoint * resultptr;
25633 resultptr = new wxPoint((wxPoint &)(result));
25634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25635 }
25636 return resultobj;
25637 fail:
25638 return NULL;
25639 }
25640
25641
25642 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25643 PyObject *resultobj;
25644 wxWindow *arg1 = (wxWindow *) 0 ;
25645 wxRect result;
25646 PyObject * obj0 = 0 ;
25647 char *kwnames[] = {
25648 (char *) "self", NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25653 if (SWIG_arg_fail(1)) SWIG_fail;
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 result = ((wxWindow const *)arg1)->GetClientRect();
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 {
25662 wxRect * resultptr;
25663 resultptr = new wxRect((wxRect &)(result));
25664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25665 }
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25673 PyObject *resultobj;
25674 wxWindow *arg1 = (wxWindow *) 0 ;
25675 wxSize result;
25676 PyObject * obj0 = 0 ;
25677 char *kwnames[] = {
25678 (char *) "self", NULL
25679 };
25680
25681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25683 if (SWIG_arg_fail(1)) SWIG_fail;
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = ((wxWindow const *)arg1)->GetBestSize();
25687
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 {
25692 wxSize * resultptr;
25693 resultptr = new wxSize((wxSize &)(result));
25694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxWindow *arg1 = (wxWindow *) 0 ;
25705 int *arg2 = (int *) 0 ;
25706 int *arg3 = (int *) 0 ;
25707 int temp2 ;
25708 int res2 = 0 ;
25709 int temp3 ;
25710 int res3 = 0 ;
25711 PyObject * obj0 = 0 ;
25712 char *kwnames[] = {
25713 (char *) "self", NULL
25714 };
25715
25716 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25717 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25720 if (SWIG_arg_fail(1)) SWIG_fail;
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25724
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 Py_INCREF(Py_None); resultobj = Py_None;
25729 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25730 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25731 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25732 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj;
25741 wxWindow *arg1 = (wxWindow *) 0 ;
25742 PyObject * obj0 = 0 ;
25743 char *kwnames[] = {
25744 (char *) "self", NULL
25745 };
25746
25747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25749 if (SWIG_arg_fail(1)) SWIG_fail;
25750 {
25751 PyThreadState* __tstate = wxPyBeginAllowThreads();
25752 (arg1)->InvalidateBestSize();
25753
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 Py_INCREF(Py_None); resultobj = Py_None;
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj;
25766 wxWindow *arg1 = (wxWindow *) 0 ;
25767 wxSize result;
25768 PyObject * obj0 = 0 ;
25769 char *kwnames[] = {
25770 (char *) "self", NULL
25771 };
25772
25773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25779
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 wxSize * resultptr;
25785 resultptr = new wxSize((wxSize &)(result));
25786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25787 }
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxWindow *arg1 = (wxWindow *) 0 ;
25797 wxSize result;
25798 PyObject * obj0 = 0 ;
25799 char *kwnames[] = {
25800 (char *) "self", NULL
25801 };
25802
25803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25805 if (SWIG_arg_fail(1)) SWIG_fail;
25806 {
25807 PyThreadState* __tstate = wxPyBeginAllowThreads();
25808 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25809
25810 wxPyEndAllowThreads(__tstate);
25811 if (PyErr_Occurred()) SWIG_fail;
25812 }
25813 {
25814 wxSize * resultptr;
25815 resultptr = new wxSize((wxSize &)(result));
25816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25817 }
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj;
25826 wxWindow *arg1 = (wxWindow *) 0 ;
25827 int arg2 = (int) wxBOTH ;
25828 PyObject * obj0 = 0 ;
25829 PyObject * obj1 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self",(char *) "direction", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 if (obj1) {
25838 {
25839 arg2 = (int)(SWIG_As_int(obj1));
25840 if (SWIG_arg_fail(2)) SWIG_fail;
25841 }
25842 }
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 (arg1)->Center(arg2);
25846
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 Py_INCREF(Py_None); resultobj = Py_None;
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxWindow *arg1 = (wxWindow *) 0 ;
25860 int arg2 = (int) wxBOTH ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 char *kwnames[] = {
25864 (char *) "self",(char *) "dir", NULL
25865 };
25866
25867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25869 if (SWIG_arg_fail(1)) SWIG_fail;
25870 if (obj1) {
25871 {
25872 arg2 = (int)(SWIG_As_int(obj1));
25873 if (SWIG_arg_fail(2)) SWIG_fail;
25874 }
25875 }
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 (arg1)->CenterOnScreen(arg2);
25879
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 Py_INCREF(Py_None); resultobj = Py_None;
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25891 PyObject *resultobj;
25892 wxWindow *arg1 = (wxWindow *) 0 ;
25893 int arg2 = (int) wxBOTH ;
25894 PyObject * obj0 = 0 ;
25895 PyObject * obj1 = 0 ;
25896 char *kwnames[] = {
25897 (char *) "self",(char *) "dir", NULL
25898 };
25899
25900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25902 if (SWIG_arg_fail(1)) SWIG_fail;
25903 if (obj1) {
25904 {
25905 arg2 = (int)(SWIG_As_int(obj1));
25906 if (SWIG_arg_fail(2)) SWIG_fail;
25907 }
25908 }
25909 {
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 (arg1)->CenterOnParent(arg2);
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 Py_INCREF(Py_None); resultobj = Py_None;
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj;
25925 wxWindow *arg1 = (wxWindow *) 0 ;
25926 PyObject * obj0 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 (arg1)->Fit();
25937
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 Py_INCREF(Py_None); resultobj = Py_None;
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 wxWindow *arg1 = (wxWindow *) 0 ;
25951 PyObject * obj0 = 0 ;
25952 char *kwnames[] = {
25953 (char *) "self", NULL
25954 };
25955
25956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25958 if (SWIG_arg_fail(1)) SWIG_fail;
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 (arg1)->FitInside();
25962
25963 wxPyEndAllowThreads(__tstate);
25964 if (PyErr_Occurred()) SWIG_fail;
25965 }
25966 Py_INCREF(Py_None); resultobj = Py_None;
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 int arg2 ;
25977 int arg3 ;
25978 int arg4 = (int) -1 ;
25979 int arg5 = (int) -1 ;
25980 int arg6 = (int) -1 ;
25981 int arg7 = (int) -1 ;
25982 PyObject * obj0 = 0 ;
25983 PyObject * obj1 = 0 ;
25984 PyObject * obj2 = 0 ;
25985 PyObject * obj3 = 0 ;
25986 PyObject * obj4 = 0 ;
25987 PyObject * obj5 = 0 ;
25988 PyObject * obj6 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 {
25997 arg2 = (int)(SWIG_As_int(obj1));
25998 if (SWIG_arg_fail(2)) SWIG_fail;
25999 }
26000 {
26001 arg3 = (int)(SWIG_As_int(obj2));
26002 if (SWIG_arg_fail(3)) SWIG_fail;
26003 }
26004 if (obj3) {
26005 {
26006 arg4 = (int)(SWIG_As_int(obj3));
26007 if (SWIG_arg_fail(4)) SWIG_fail;
26008 }
26009 }
26010 if (obj4) {
26011 {
26012 arg5 = (int)(SWIG_As_int(obj4));
26013 if (SWIG_arg_fail(5)) SWIG_fail;
26014 }
26015 }
26016 if (obj5) {
26017 {
26018 arg6 = (int)(SWIG_As_int(obj5));
26019 if (SWIG_arg_fail(6)) SWIG_fail;
26020 }
26021 }
26022 if (obj6) {
26023 {
26024 arg7 = (int)(SWIG_As_int(obj6));
26025 if (SWIG_arg_fail(7)) SWIG_fail;
26026 }
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 Py_INCREF(Py_None); resultobj = Py_None;
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26043 PyObject *resultobj;
26044 wxWindow *arg1 = (wxWindow *) 0 ;
26045 wxSize *arg2 = 0 ;
26046 wxSize const &arg3_defvalue = wxDefaultSize ;
26047 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26048 wxSize const &arg4_defvalue = wxDefaultSize ;
26049 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26050 wxSize temp2 ;
26051 wxSize temp3 ;
26052 wxSize temp4 ;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 PyObject * obj2 = 0 ;
26056 PyObject * obj3 = 0 ;
26057 char *kwnames[] = {
26058 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26059 };
26060
26061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26063 if (SWIG_arg_fail(1)) SWIG_fail;
26064 {
26065 arg2 = &temp2;
26066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26067 }
26068 if (obj2) {
26069 {
26070 arg3 = &temp3;
26071 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26072 }
26073 }
26074 if (obj3) {
26075 {
26076 arg4 = &temp4;
26077 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26078 }
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26083
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 Py_INCREF(Py_None); resultobj = Py_None;
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj;
26096 wxWindow *arg1 = (wxWindow *) 0 ;
26097 int arg2 ;
26098 int arg3 ;
26099 int arg4 = (int) -1 ;
26100 int arg5 = (int) -1 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 PyObject * obj2 = 0 ;
26104 PyObject * obj3 = 0 ;
26105 PyObject * obj4 = 0 ;
26106 char *kwnames[] = {
26107 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26108 };
26109
26110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26112 if (SWIG_arg_fail(1)) SWIG_fail;
26113 {
26114 arg2 = (int)(SWIG_As_int(obj1));
26115 if (SWIG_arg_fail(2)) SWIG_fail;
26116 }
26117 {
26118 arg3 = (int)(SWIG_As_int(obj2));
26119 if (SWIG_arg_fail(3)) SWIG_fail;
26120 }
26121 if (obj3) {
26122 {
26123 arg4 = (int)(SWIG_As_int(obj3));
26124 if (SWIG_arg_fail(4)) SWIG_fail;
26125 }
26126 }
26127 if (obj4) {
26128 {
26129 arg5 = (int)(SWIG_As_int(obj4));
26130 if (SWIG_arg_fail(5)) SWIG_fail;
26131 }
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 wxSize *arg2 = 0 ;
26151 wxSize const &arg3_defvalue = wxDefaultSize ;
26152 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26153 wxSize temp2 ;
26154 wxSize temp3 ;
26155 PyObject * obj0 = 0 ;
26156 PyObject * obj1 = 0 ;
26157 PyObject * obj2 = 0 ;
26158 char *kwnames[] = {
26159 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26160 };
26161
26162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26164 if (SWIG_arg_fail(1)) SWIG_fail;
26165 {
26166 arg2 = &temp2;
26167 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26168 }
26169 if (obj2) {
26170 {
26171 arg3 = &temp3;
26172 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26173 }
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26178
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 Py_INCREF(Py_None); resultobj = Py_None;
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26190 PyObject *resultobj;
26191 wxWindow *arg1 = (wxWindow *) 0 ;
26192 wxSize result;
26193 PyObject * obj0 = 0 ;
26194 char *kwnames[] = {
26195 (char *) "self", NULL
26196 };
26197
26198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26200 if (SWIG_arg_fail(1)) SWIG_fail;
26201 {
26202 PyThreadState* __tstate = wxPyBeginAllowThreads();
26203 result = ((wxWindow const *)arg1)->GetMaxSize();
26204
26205 wxPyEndAllowThreads(__tstate);
26206 if (PyErr_Occurred()) SWIG_fail;
26207 }
26208 {
26209 wxSize * resultptr;
26210 resultptr = new wxSize((wxSize &)(result));
26211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26212 }
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj;
26221 wxWindow *arg1 = (wxWindow *) 0 ;
26222 wxSize result;
26223 PyObject * obj0 = 0 ;
26224 char *kwnames[] = {
26225 (char *) "self", NULL
26226 };
26227
26228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = ((wxWindow const *)arg1)->GetMinSize();
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 wxSize * resultptr;
26240 resultptr = new wxSize((wxSize &)(result));
26241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxWindow *arg1 = (wxWindow *) 0 ;
26252 wxSize *arg2 = 0 ;
26253 wxSize temp2 ;
26254 PyObject * obj0 = 0 ;
26255 PyObject * obj1 = 0 ;
26256 char *kwnames[] = {
26257 (char *) "self",(char *) "minSize", NULL
26258 };
26259
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 arg2 = &temp2;
26265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26266 }
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 (arg1)->SetMinSize((wxSize const &)*arg2);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 Py_INCREF(Py_None); resultobj = Py_None;
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj;
26283 wxWindow *arg1 = (wxWindow *) 0 ;
26284 wxSize *arg2 = 0 ;
26285 wxSize temp2 ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char *kwnames[] = {
26289 (char *) "self",(char *) "maxSize", NULL
26290 };
26291
26292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26294 if (SWIG_arg_fail(1)) SWIG_fail;
26295 {
26296 arg2 = &temp2;
26297 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26298 }
26299 {
26300 PyThreadState* __tstate = wxPyBeginAllowThreads();
26301 (arg1)->SetMaxSize((wxSize const &)*arg2);
26302
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 Py_INCREF(Py_None); resultobj = Py_None;
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj;
26315 wxWindow *arg1 = (wxWindow *) 0 ;
26316 int result;
26317 PyObject * obj0 = 0 ;
26318 char *kwnames[] = {
26319 (char *) "self", NULL
26320 };
26321
26322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26324 if (SWIG_arg_fail(1)) SWIG_fail;
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26328
26329 wxPyEndAllowThreads(__tstate);
26330 if (PyErr_Occurred()) SWIG_fail;
26331 }
26332 {
26333 resultobj = SWIG_From_int((int)(result));
26334 }
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxWindow *arg1 = (wxWindow *) 0 ;
26344 int result;
26345 PyObject * obj0 = 0 ;
26346 char *kwnames[] = {
26347 (char *) "self", NULL
26348 };
26349
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26352 if (SWIG_arg_fail(1)) SWIG_fail;
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26356
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = SWIG_From_int((int)(result));
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj;
26371 wxWindow *arg1 = (wxWindow *) 0 ;
26372 int result;
26373 PyObject * obj0 = 0 ;
26374 char *kwnames[] = {
26375 (char *) "self", NULL
26376 };
26377
26378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26380 if (SWIG_arg_fail(1)) SWIG_fail;
26381 {
26382 PyThreadState* __tstate = wxPyBeginAllowThreads();
26383 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26384
26385 wxPyEndAllowThreads(__tstate);
26386 if (PyErr_Occurred()) SWIG_fail;
26387 }
26388 {
26389 resultobj = SWIG_From_int((int)(result));
26390 }
26391 return resultobj;
26392 fail:
26393 return NULL;
26394 }
26395
26396
26397 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj;
26399 wxWindow *arg1 = (wxWindow *) 0 ;
26400 int result;
26401 PyObject * obj0 = 0 ;
26402 char *kwnames[] = {
26403 (char *) "self", NULL
26404 };
26405
26406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26408 if (SWIG_arg_fail(1)) SWIG_fail;
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 resultobj = SWIG_From_int((int)(result));
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxWindow *arg1 = (wxWindow *) 0 ;
26428 wxSize *arg2 = 0 ;
26429 wxSize temp2 ;
26430 PyObject * obj0 = 0 ;
26431 PyObject * obj1 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self",(char *) "size", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 arg2 = &temp2;
26441 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 int arg2 ;
26461 int arg3 ;
26462 PyObject * obj0 = 0 ;
26463 PyObject * obj1 = 0 ;
26464 PyObject * obj2 = 0 ;
26465 char *kwnames[] = {
26466 (char *) "self",(char *) "w",(char *) "h", NULL
26467 };
26468
26469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26471 if (SWIG_arg_fail(1)) SWIG_fail;
26472 {
26473 arg2 = (int)(SWIG_As_int(obj1));
26474 if (SWIG_arg_fail(2)) SWIG_fail;
26475 }
26476 {
26477 arg3 = (int)(SWIG_As_int(obj2));
26478 if (SWIG_arg_fail(3)) SWIG_fail;
26479 }
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 (arg1)->SetVirtualSize(arg2,arg3);
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 Py_INCREF(Py_None); resultobj = Py_None;
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxWindow *arg1 = (wxWindow *) 0 ;
26497 wxSize result;
26498 PyObject * obj0 = 0 ;
26499 char *kwnames[] = {
26500 (char *) "self", NULL
26501 };
26502
26503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26505 if (SWIG_arg_fail(1)) SWIG_fail;
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = ((wxWindow const *)arg1)->GetVirtualSize();
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 {
26514 wxSize * resultptr;
26515 resultptr = new wxSize((wxSize &)(result));
26516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26525 PyObject *resultobj;
26526 wxWindow *arg1 = (wxWindow *) 0 ;
26527 int *arg2 = (int *) 0 ;
26528 int *arg3 = (int *) 0 ;
26529 int temp2 ;
26530 int res2 = 0 ;
26531 int temp3 ;
26532 int res3 = 0 ;
26533 PyObject * obj0 = 0 ;
26534 char *kwnames[] = {
26535 (char *) "self", NULL
26536 };
26537
26538 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26539 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26542 if (SWIG_arg_fail(1)) SWIG_fail;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 Py_INCREF(Py_None); resultobj = Py_None;
26551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26552 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26554 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj;
26563 wxWindow *arg1 = (wxWindow *) 0 ;
26564 wxSize result;
26565 PyObject * obj0 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(1)) SWIG_fail;
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26576
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 {
26581 wxSize * resultptr;
26582 resultptr = new wxSize((wxSize &)(result));
26583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26584 }
26585 return resultobj;
26586 fail:
26587 return NULL;
26588 }
26589
26590
26591 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj;
26593 wxWindow *arg1 = (wxWindow *) 0 ;
26594 bool arg2 = (bool) true ;
26595 bool result;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char *kwnames[] = {
26599 (char *) "self",(char *) "show", NULL
26600 };
26601
26602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26604 if (SWIG_arg_fail(1)) SWIG_fail;
26605 if (obj1) {
26606 {
26607 arg2 = (bool)(SWIG_As_bool(obj1));
26608 if (SWIG_arg_fail(2)) SWIG_fail;
26609 }
26610 }
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 result = (bool)(arg1)->Show(arg2);
26614
26615 wxPyEndAllowThreads(__tstate);
26616 if (PyErr_Occurred()) SWIG_fail;
26617 }
26618 {
26619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26620 }
26621 return resultobj;
26622 fail:
26623 return NULL;
26624 }
26625
26626
26627 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj;
26629 wxWindow *arg1 = (wxWindow *) 0 ;
26630 bool result;
26631 PyObject * obj0 = 0 ;
26632 char *kwnames[] = {
26633 (char *) "self", NULL
26634 };
26635
26636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26638 if (SWIG_arg_fail(1)) SWIG_fail;
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 result = (bool)(arg1)->Hide();
26642
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 {
26647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26648 }
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj;
26657 wxWindow *arg1 = (wxWindow *) 0 ;
26658 bool arg2 = (bool) true ;
26659 bool result;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662 char *kwnames[] = {
26663 (char *) "self",(char *) "enable", NULL
26664 };
26665
26666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26668 if (SWIG_arg_fail(1)) SWIG_fail;
26669 if (obj1) {
26670 {
26671 arg2 = (bool)(SWIG_As_bool(obj1));
26672 if (SWIG_arg_fail(2)) SWIG_fail;
26673 }
26674 }
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 result = (bool)(arg1)->Enable(arg2);
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 {
26683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26684 }
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj;
26693 wxWindow *arg1 = (wxWindow *) 0 ;
26694 bool result;
26695 PyObject * obj0 = 0 ;
26696 char *kwnames[] = {
26697 (char *) "self", NULL
26698 };
26699
26700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26702 if (SWIG_arg_fail(1)) SWIG_fail;
26703 {
26704 PyThreadState* __tstate = wxPyBeginAllowThreads();
26705 result = (bool)(arg1)->Disable();
26706
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 {
26711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26712 }
26713 return resultobj;
26714 fail:
26715 return NULL;
26716 }
26717
26718
26719 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 bool result;
26723 PyObject * obj0 = 0 ;
26724 char *kwnames[] = {
26725 (char *) "self", NULL
26726 };
26727
26728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26730 if (SWIG_arg_fail(1)) SWIG_fail;
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (bool)((wxWindow const *)arg1)->IsShown();
26734
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj;
26749 wxWindow *arg1 = (wxWindow *) 0 ;
26750 bool result;
26751 PyObject * obj0 = 0 ;
26752 char *kwnames[] = {
26753 (char *) "self", NULL
26754 };
26755
26756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26758 if (SWIG_arg_fail(1)) SWIG_fail;
26759 {
26760 PyThreadState* __tstate = wxPyBeginAllowThreads();
26761 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26762
26763 wxPyEndAllowThreads(__tstate);
26764 if (PyErr_Occurred()) SWIG_fail;
26765 }
26766 {
26767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26768 }
26769 return resultobj;
26770 fail:
26771 return NULL;
26772 }
26773
26774
26775 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26776 PyObject *resultobj;
26777 wxWindow *arg1 = (wxWindow *) 0 ;
26778 long arg2 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char *kwnames[] = {
26782 (char *) "self",(char *) "style", NULL
26783 };
26784
26785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26787 if (SWIG_arg_fail(1)) SWIG_fail;
26788 {
26789 arg2 = (long)(SWIG_As_long(obj1));
26790 if (SWIG_arg_fail(2)) SWIG_fail;
26791 }
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 (arg1)->SetWindowStyleFlag(arg2);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 Py_INCREF(Py_None); resultobj = Py_None;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj;
26808 wxWindow *arg1 = (wxWindow *) 0 ;
26809 long result;
26810 PyObject * obj0 = 0 ;
26811 char *kwnames[] = {
26812 (char *) "self", NULL
26813 };
26814
26815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26817 if (SWIG_arg_fail(1)) SWIG_fail;
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26821
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 {
26826 resultobj = SWIG_From_long((long)(result));
26827 }
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj;
26836 wxWindow *arg1 = (wxWindow *) 0 ;
26837 int arg2 ;
26838 bool result;
26839 PyObject * obj0 = 0 ;
26840 PyObject * obj1 = 0 ;
26841 char *kwnames[] = {
26842 (char *) "self",(char *) "flag", NULL
26843 };
26844
26845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26847 if (SWIG_arg_fail(1)) SWIG_fail;
26848 {
26849 arg2 = (int)(SWIG_As_int(obj1));
26850 if (SWIG_arg_fail(2)) SWIG_fail;
26851 }
26852 {
26853 PyThreadState* __tstate = wxPyBeginAllowThreads();
26854 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26855
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 {
26860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26861 }
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj;
26870 wxWindow *arg1 = (wxWindow *) 0 ;
26871 bool result;
26872 PyObject * obj0 = 0 ;
26873 char *kwnames[] = {
26874 (char *) "self", NULL
26875 };
26876
26877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26879 if (SWIG_arg_fail(1)) SWIG_fail;
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = (bool)((wxWindow const *)arg1)->IsRetained();
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 long arg2 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 char *kwnames[] = {
26903 (char *) "self",(char *) "exStyle", NULL
26904 };
26905
26906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26908 if (SWIG_arg_fail(1)) SWIG_fail;
26909 {
26910 arg2 = (long)(SWIG_As_long(obj1));
26911 if (SWIG_arg_fail(2)) SWIG_fail;
26912 }
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 (arg1)->SetExtraStyle(arg2);
26916
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 Py_INCREF(Py_None); resultobj = Py_None;
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26928 PyObject *resultobj;
26929 wxWindow *arg1 = (wxWindow *) 0 ;
26930 long result;
26931 PyObject * obj0 = 0 ;
26932 char *kwnames[] = {
26933 (char *) "self", NULL
26934 };
26935
26936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26938 if (SWIG_arg_fail(1)) SWIG_fail;
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 {
26947 resultobj = SWIG_From_long((long)(result));
26948 }
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj;
26957 wxWindow *arg1 = (wxWindow *) 0 ;
26958 bool arg2 = (bool) true ;
26959 PyObject * obj0 = 0 ;
26960 PyObject * obj1 = 0 ;
26961 char *kwnames[] = {
26962 (char *) "self",(char *) "modal", NULL
26963 };
26964
26965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26967 if (SWIG_arg_fail(1)) SWIG_fail;
26968 if (obj1) {
26969 {
26970 arg2 = (bool)(SWIG_As_bool(obj1));
26971 if (SWIG_arg_fail(2)) SWIG_fail;
26972 }
26973 }
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 (arg1)->MakeModal(arg2);
26977
26978 wxPyEndAllowThreads(__tstate);
26979 if (PyErr_Occurred()) SWIG_fail;
26980 }
26981 Py_INCREF(Py_None); resultobj = Py_None;
26982 return resultobj;
26983 fail:
26984 return NULL;
26985 }
26986
26987
26988 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26989 PyObject *resultobj;
26990 wxWindow *arg1 = (wxWindow *) 0 ;
26991 bool arg2 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self",(char *) "enableTheme", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 arg2 = (bool)(SWIG_As_bool(obj1));
27003 if (SWIG_arg_fail(2)) SWIG_fail;
27004 }
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 (arg1)->SetThemeEnabled(arg2);
27008
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 Py_INCREF(Py_None); resultobj = Py_None;
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxWindow *arg1 = (wxWindow *) 0 ;
27022 bool result;
27023 PyObject * obj0 = 0 ;
27024 char *kwnames[] = {
27025 (char *) "self", NULL
27026 };
27027
27028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27030 if (SWIG_arg_fail(1)) SWIG_fail;
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 {
27039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27040 }
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj;
27049 wxWindow *arg1 = (wxWindow *) 0 ;
27050 PyObject * obj0 = 0 ;
27051 char *kwnames[] = {
27052 (char *) "self", NULL
27053 };
27054
27055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27057 if (SWIG_arg_fail(1)) SWIG_fail;
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 (arg1)->SetFocus();
27061
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 Py_INCREF(Py_None); resultobj = Py_None;
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27073 PyObject *resultobj;
27074 wxWindow *arg1 = (wxWindow *) 0 ;
27075 PyObject * obj0 = 0 ;
27076 char *kwnames[] = {
27077 (char *) "self", NULL
27078 };
27079
27080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27082 if (SWIG_arg_fail(1)) SWIG_fail;
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 (arg1)->SetFocusFromKbd();
27086
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 Py_INCREF(Py_None); resultobj = Py_None;
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj;
27099 wxWindow *result;
27100 char *kwnames[] = {
27101 NULL
27102 };
27103
27104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27105 {
27106 if (!wxPyCheckForApp()) SWIG_fail;
27107 PyThreadState* __tstate = wxPyBeginAllowThreads();
27108 result = (wxWindow *)wxWindow::FindFocus();
27109
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 {
27114 resultobj = wxPyMake_wxObject(result, 0);
27115 }
27116 return resultobj;
27117 fail:
27118 return NULL;
27119 }
27120
27121
27122 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27123 PyObject *resultobj;
27124 wxWindow *arg1 = (wxWindow *) 0 ;
27125 bool result;
27126 PyObject * obj0 = 0 ;
27127 char *kwnames[] = {
27128 (char *) "self", NULL
27129 };
27130
27131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27133 if (SWIG_arg_fail(1)) SWIG_fail;
27134 {
27135 PyThreadState* __tstate = wxPyBeginAllowThreads();
27136 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27137
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 {
27142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27143 }
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj;
27152 wxWindow *arg1 = (wxWindow *) 0 ;
27153 bool result;
27154 PyObject * obj0 = 0 ;
27155 char *kwnames[] = {
27156 (char *) "self", NULL
27157 };
27158
27159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27161 if (SWIG_arg_fail(1)) SWIG_fail;
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27165
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27171 }
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27179 PyObject *resultobj;
27180 wxWindow *arg1 = (wxWindow *) 0 ;
27181 wxWindow *result;
27182 PyObject * obj0 = 0 ;
27183 char *kwnames[] = {
27184 (char *) "self", NULL
27185 };
27186
27187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(1)) SWIG_fail;
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27193
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 resultobj = wxPyMake_wxObject(result, 0);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27207 PyObject *resultobj;
27208 wxWindow *arg1 = (wxWindow *) 0 ;
27209 wxWindow *arg2 = (wxWindow *) 0 ;
27210 wxWindow *result;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "self",(char *) "child", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27225
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 {
27230 resultobj = wxPyMake_wxObject(result, 0);
27231 }
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj;
27240 wxWindow *arg1 = (wxWindow *) 0 ;
27241 wxWindow *arg2 = (wxWindow *) 0 ;
27242 PyObject * obj0 = 0 ;
27243 PyObject * obj1 = 0 ;
27244 char *kwnames[] = {
27245 (char *) "self",(char *) "win", NULL
27246 };
27247
27248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(2)) SWIG_fail;
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 (arg1)->SetTmpDefaultItem(arg2);
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 Py_INCREF(Py_None); resultobj = Py_None;
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj;
27269 wxWindow *arg1 = (wxWindow *) 0 ;
27270 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27271 bool result;
27272 PyObject * obj0 = 0 ;
27273 PyObject * obj1 = 0 ;
27274 char *kwnames[] = {
27275 (char *) "self",(char *) "flags", NULL
27276 };
27277
27278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27280 if (SWIG_arg_fail(1)) SWIG_fail;
27281 if (obj1) {
27282 {
27283 arg2 = (int)(SWIG_As_int(obj1));
27284 if (SWIG_arg_fail(2)) SWIG_fail;
27285 }
27286 }
27287 {
27288 PyThreadState* __tstate = wxPyBeginAllowThreads();
27289 result = (bool)(arg1)->Navigate(arg2);
27290
27291 wxPyEndAllowThreads(__tstate);
27292 if (PyErr_Occurred()) SWIG_fail;
27293 }
27294 {
27295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27296 }
27297 return resultobj;
27298 fail:
27299 return NULL;
27300 }
27301
27302
27303 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxWindow *arg1 = (wxWindow *) 0 ;
27306 wxWindow *arg2 = (wxWindow *) 0 ;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self",(char *) "win", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(2)) SWIG_fail;
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 (arg1)->MoveAfterInTabOrder(arg2);
27321
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 Py_INCREF(Py_None); resultobj = Py_None;
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj;
27334 wxWindow *arg1 = (wxWindow *) 0 ;
27335 wxWindow *arg2 = (wxWindow *) 0 ;
27336 PyObject * obj0 = 0 ;
27337 PyObject * obj1 = 0 ;
27338 char *kwnames[] = {
27339 (char *) "self",(char *) "win", NULL
27340 };
27341
27342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27344 if (SWIG_arg_fail(1)) SWIG_fail;
27345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27346 if (SWIG_arg_fail(2)) SWIG_fail;
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 (arg1)->MoveBeforeInTabOrder(arg2);
27350
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 Py_INCREF(Py_None); resultobj = Py_None;
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27362 PyObject *resultobj;
27363 wxWindow *arg1 = (wxWindow *) 0 ;
27364 PyObject *result;
27365 PyObject * obj0 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 result = (PyObject *)wxWindow_GetChildren(arg1);
27376
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = result;
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj;
27389 wxWindow *arg1 = (wxWindow *) 0 ;
27390 wxWindow *result;
27391 PyObject * obj0 = 0 ;
27392 char *kwnames[] = {
27393 (char *) "self", NULL
27394 };
27395
27396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27398 if (SWIG_arg_fail(1)) SWIG_fail;
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27402
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 {
27407 resultobj = wxPyMake_wxObject(result, 0);
27408 }
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj;
27417 wxWindow *arg1 = (wxWindow *) 0 ;
27418 wxWindow *result;
27419 PyObject * obj0 = 0 ;
27420 char *kwnames[] = {
27421 (char *) "self", NULL
27422 };
27423
27424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27426 if (SWIG_arg_fail(1)) SWIG_fail;
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27430
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 {
27435 resultobj = wxPyMake_wxObject(result, 0);
27436 }
27437 return resultobj;
27438 fail:
27439 return NULL;
27440 }
27441
27442
27443 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27444 PyObject *resultobj;
27445 wxWindow *arg1 = (wxWindow *) 0 ;
27446 bool result;
27447 PyObject * obj0 = 0 ;
27448 char *kwnames[] = {
27449 (char *) "self", NULL
27450 };
27451
27452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27454 if (SWIG_arg_fail(1)) SWIG_fail;
27455 {
27456 PyThreadState* __tstate = wxPyBeginAllowThreads();
27457 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27458
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 {
27463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27464 }
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27472 PyObject *resultobj;
27473 wxWindow *arg1 = (wxWindow *) 0 ;
27474 wxWindow *arg2 = (wxWindow *) 0 ;
27475 bool result;
27476 PyObject * obj0 = 0 ;
27477 PyObject * obj1 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self",(char *) "newParent", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(1)) SWIG_fail;
27485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(2)) SWIG_fail;
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 result = (bool)(arg1)->Reparent(arg2);
27490
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 {
27495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27496 }
27497 return resultobj;
27498 fail:
27499 return NULL;
27500 }
27501
27502
27503 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27504 PyObject *resultobj;
27505 wxWindow *arg1 = (wxWindow *) 0 ;
27506 wxWindow *arg2 = (wxWindow *) 0 ;
27507 PyObject * obj0 = 0 ;
27508 PyObject * obj1 = 0 ;
27509 char *kwnames[] = {
27510 (char *) "self",(char *) "child", NULL
27511 };
27512
27513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(2)) SWIG_fail;
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 (arg1)->AddChild(arg2);
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 Py_INCREF(Py_None); resultobj = Py_None;
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj;
27534 wxWindow *arg1 = (wxWindow *) 0 ;
27535 wxWindow *arg2 = (wxWindow *) 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char *kwnames[] = {
27539 (char *) "self",(char *) "child", NULL
27540 };
27541
27542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27544 if (SWIG_arg_fail(1)) SWIG_fail;
27545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(2)) SWIG_fail;
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->RemoveChild(arg2);
27550
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 Py_INCREF(Py_None); resultobj = Py_None;
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27562 PyObject *resultobj;
27563 wxWindow *arg1 = (wxWindow *) 0 ;
27564 long arg2 ;
27565 wxWindow *result;
27566 PyObject * obj0 = 0 ;
27567 PyObject * obj1 = 0 ;
27568 char *kwnames[] = {
27569 (char *) "self",(char *) "winid", NULL
27570 };
27571
27572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27574 if (SWIG_arg_fail(1)) SWIG_fail;
27575 {
27576 arg2 = (long)(SWIG_As_long(obj1));
27577 if (SWIG_arg_fail(2)) SWIG_fail;
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = (wxWindow *)(arg1)->FindWindow(arg2);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = wxPyMake_wxObject(result, 0);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj;
27597 wxWindow *arg1 = (wxWindow *) 0 ;
27598 wxString *arg2 = 0 ;
27599 wxWindow *result;
27600 bool temp2 = false ;
27601 PyObject * obj0 = 0 ;
27602 PyObject * obj1 = 0 ;
27603 char *kwnames[] = {
27604 (char *) "self",(char *) "name", NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27609 if (SWIG_arg_fail(1)) SWIG_fail;
27610 {
27611 arg2 = wxString_in_helper(obj1);
27612 if (arg2 == NULL) SWIG_fail;
27613 temp2 = true;
27614 }
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 {
27623 resultobj = wxPyMake_wxObject(result, 0);
27624 }
27625 {
27626 if (temp2)
27627 delete arg2;
27628 }
27629 return resultobj;
27630 fail:
27631 {
27632 if (temp2)
27633 delete arg2;
27634 }
27635 return NULL;
27636 }
27637
27638
27639 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj;
27641 wxWindow *arg1 = (wxWindow *) 0 ;
27642 wxEvtHandler *result;
27643 PyObject * obj0 = 0 ;
27644 char *kwnames[] = {
27645 (char *) "self", NULL
27646 };
27647
27648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27650 if (SWIG_arg_fail(1)) SWIG_fail;
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27654
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 {
27659 resultobj = wxPyMake_wxObject(result, 0);
27660 }
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxWindow *arg1 = (wxWindow *) 0 ;
27670 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self",(char *) "handler", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(1)) SWIG_fail;
27680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(2)) SWIG_fail;
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 (arg1)->SetEventHandler(arg2);
27685
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 Py_INCREF(Py_None); resultobj = Py_None;
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxWindow *arg1 = (wxWindow *) 0 ;
27699 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27700 PyObject * obj0 = 0 ;
27701 PyObject * obj1 = 0 ;
27702 char *kwnames[] = {
27703 (char *) "self",(char *) "handler", NULL
27704 };
27705
27706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(2)) SWIG_fail;
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 (arg1)->PushEventHandler(arg2);
27714
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 Py_INCREF(Py_None); resultobj = Py_None;
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj;
27727 wxWindow *arg1 = (wxWindow *) 0 ;
27728 bool arg2 = (bool) false ;
27729 wxEvtHandler *result;
27730 PyObject * obj0 = 0 ;
27731 PyObject * obj1 = 0 ;
27732 char *kwnames[] = {
27733 (char *) "self",(char *) "deleteHandler", NULL
27734 };
27735
27736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27738 if (SWIG_arg_fail(1)) SWIG_fail;
27739 if (obj1) {
27740 {
27741 arg2 = (bool)(SWIG_As_bool(obj1));
27742 if (SWIG_arg_fail(2)) SWIG_fail;
27743 }
27744 }
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27748
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = wxPyMake_wxObject(result, 0);
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj;
27763 wxWindow *arg1 = (wxWindow *) 0 ;
27764 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27765 bool result;
27766 PyObject * obj0 = 0 ;
27767 PyObject * obj1 = 0 ;
27768 char *kwnames[] = {
27769 (char *) "self",(char *) "handler", NULL
27770 };
27771
27772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(2)) SWIG_fail;
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (bool)(arg1)->RemoveEventHandler(arg2);
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj;
27795 wxWindow *arg1 = (wxWindow *) 0 ;
27796 wxValidator *arg2 = 0 ;
27797 PyObject * obj0 = 0 ;
27798 PyObject * obj1 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self",(char *) "validator", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 {
27807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27808 if (SWIG_arg_fail(2)) SWIG_fail;
27809 if (arg2 == NULL) {
27810 SWIG_null_ref("wxValidator");
27811 }
27812 if (SWIG_arg_fail(2)) SWIG_fail;
27813 }
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->SetValidator((wxValidator const &)*arg2);
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 Py_INCREF(Py_None); resultobj = Py_None;
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj;
27830 wxWindow *arg1 = (wxWindow *) 0 ;
27831 wxValidator *result;
27832 PyObject * obj0 = 0 ;
27833 char *kwnames[] = {
27834 (char *) "self", NULL
27835 };
27836
27837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (wxValidator *)(arg1)->GetValidator();
27843
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 {
27848 resultobj = wxPyMake_wxObject(result, 0);
27849 }
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxWindow *arg1 = (wxWindow *) 0 ;
27859 bool result;
27860 PyObject * obj0 = 0 ;
27861 char *kwnames[] = {
27862 (char *) "self", NULL
27863 };
27864
27865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (bool)(arg1)->Validate();
27871
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj;
27886 wxWindow *arg1 = (wxWindow *) 0 ;
27887 bool result;
27888 PyObject * obj0 = 0 ;
27889 char *kwnames[] = {
27890 (char *) "self", NULL
27891 };
27892
27893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27895 if (SWIG_arg_fail(1)) SWIG_fail;
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (bool)(arg1)->TransferDataToWindow();
27899
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj;
27914 wxWindow *arg1 = (wxWindow *) 0 ;
27915 bool result;
27916 PyObject * obj0 = 0 ;
27917 char *kwnames[] = {
27918 (char *) "self", NULL
27919 };
27920
27921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27923 if (SWIG_arg_fail(1)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (bool)(arg1)->TransferDataFromWindow();
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 {
27932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27933 }
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27941 PyObject *resultobj;
27942 wxWindow *arg1 = (wxWindow *) 0 ;
27943 PyObject * obj0 = 0 ;
27944 char *kwnames[] = {
27945 (char *) "self", NULL
27946 };
27947
27948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27950 if (SWIG_arg_fail(1)) SWIG_fail;
27951 {
27952 PyThreadState* __tstate = wxPyBeginAllowThreads();
27953 (arg1)->InitDialog();
27954
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 Py_INCREF(Py_None); resultobj = Py_None;
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxAcceleratorTable *arg2 = 0 ;
27969 PyObject * obj0 = 0 ;
27970 PyObject * obj1 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "self",(char *) "accel", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 {
27979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27980 if (SWIG_arg_fail(2)) SWIG_fail;
27981 if (arg2 == NULL) {
27982 SWIG_null_ref("wxAcceleratorTable");
27983 }
27984 if (SWIG_arg_fail(2)) SWIG_fail;
27985 }
27986 {
27987 PyThreadState* __tstate = wxPyBeginAllowThreads();
27988 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27989
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 Py_INCREF(Py_None); resultobj = Py_None;
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj;
28002 wxWindow *arg1 = (wxWindow *) 0 ;
28003 wxAcceleratorTable *result;
28004 PyObject * obj0 = 0 ;
28005 char *kwnames[] = {
28006 (char *) "self", NULL
28007 };
28008
28009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(1)) SWIG_fail;
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28015
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj;
28028 wxWindow *arg1 = (wxWindow *) 0 ;
28029 int arg2 ;
28030 int arg3 ;
28031 int arg4 ;
28032 bool result;
28033 PyObject * obj0 = 0 ;
28034 PyObject * obj1 = 0 ;
28035 PyObject * obj2 = 0 ;
28036 PyObject * obj3 = 0 ;
28037 char *kwnames[] = {
28038 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28039 };
28040
28041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28043 if (SWIG_arg_fail(1)) SWIG_fail;
28044 {
28045 arg2 = (int)(SWIG_As_int(obj1));
28046 if (SWIG_arg_fail(2)) SWIG_fail;
28047 }
28048 {
28049 arg3 = (int)(SWIG_As_int(obj2));
28050 if (SWIG_arg_fail(3)) SWIG_fail;
28051 }
28052 {
28053 arg4 = (int)(SWIG_As_int(obj3));
28054 if (SWIG_arg_fail(4)) SWIG_fail;
28055 }
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28059
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 {
28064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28065 }
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj;
28074 wxWindow *arg1 = (wxWindow *) 0 ;
28075 int arg2 ;
28076 bool result;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char *kwnames[] = {
28080 (char *) "self",(char *) "hotkeyId", NULL
28081 };
28082
28083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28085 if (SWIG_arg_fail(1)) SWIG_fail;
28086 {
28087 arg2 = (int)(SWIG_As_int(obj1));
28088 if (SWIG_arg_fail(2)) SWIG_fail;
28089 }
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 {
28098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28099 }
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj;
28108 wxWindow *arg1 = (wxWindow *) 0 ;
28109 wxPoint *arg2 = 0 ;
28110 wxPoint result;
28111 wxPoint temp2 ;
28112 PyObject * obj0 = 0 ;
28113 PyObject * obj1 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self",(char *) "pt", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 arg2 = &temp2;
28123 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28124 }
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28128
28129 wxPyEndAllowThreads(__tstate);
28130 if (PyErr_Occurred()) SWIG_fail;
28131 }
28132 {
28133 wxPoint * resultptr;
28134 resultptr = new wxPoint((wxPoint &)(result));
28135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28136 }
28137 return resultobj;
28138 fail:
28139 return NULL;
28140 }
28141
28142
28143 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28144 PyObject *resultobj;
28145 wxWindow *arg1 = (wxWindow *) 0 ;
28146 wxSize *arg2 = 0 ;
28147 wxSize result;
28148 wxSize temp2 ;
28149 PyObject * obj0 = 0 ;
28150 PyObject * obj1 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self",(char *) "sz", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 arg2 = &temp2;
28160 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 {
28170 wxSize * resultptr;
28171 resultptr = new wxSize((wxSize &)(result));
28172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 wxPoint *arg2 = 0 ;
28184 wxPoint result;
28185 wxPoint temp2 ;
28186 PyObject * obj0 = 0 ;
28187 PyObject * obj1 = 0 ;
28188 char *kwnames[] = {
28189 (char *) "self",(char *) "pt", NULL
28190 };
28191
28192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28194 if (SWIG_arg_fail(1)) SWIG_fail;
28195 {
28196 arg2 = &temp2;
28197 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28198 }
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28202
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 {
28207 wxPoint * resultptr;
28208 resultptr = new wxPoint((wxPoint &)(result));
28209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28210 }
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28218 PyObject *resultobj;
28219 wxWindow *arg1 = (wxWindow *) 0 ;
28220 wxSize *arg2 = 0 ;
28221 wxSize result;
28222 wxSize temp2 ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char *kwnames[] = {
28226 (char *) "self",(char *) "sz", NULL
28227 };
28228
28229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28231 if (SWIG_arg_fail(1)) SWIG_fail;
28232 {
28233 arg2 = &temp2;
28234 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28235 }
28236 {
28237 PyThreadState* __tstate = wxPyBeginAllowThreads();
28238 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28239
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 {
28244 wxSize * resultptr;
28245 resultptr = new wxSize((wxSize &)(result));
28246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 wxPoint *arg2 = 0 ;
28258 wxPoint result;
28259 wxPoint temp2 ;
28260 PyObject * obj0 = 0 ;
28261 PyObject * obj1 = 0 ;
28262 char *kwnames[] = {
28263 (char *) "self",(char *) "pt", NULL
28264 };
28265
28266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28268 if (SWIG_arg_fail(1)) SWIG_fail;
28269 {
28270 arg2 = &temp2;
28271 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28272 }
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 {
28281 wxPoint * resultptr;
28282 resultptr = new wxPoint((wxPoint &)(result));
28283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28284 }
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 wxSize *arg2 = 0 ;
28295 wxSize result;
28296 wxSize temp2 ;
28297 PyObject * obj0 = 0 ;
28298 PyObject * obj1 = 0 ;
28299 char *kwnames[] = {
28300 (char *) "self",(char *) "sz", NULL
28301 };
28302
28303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28305 if (SWIG_arg_fail(1)) SWIG_fail;
28306 {
28307 arg2 = &temp2;
28308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28309 }
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 wxSize * resultptr;
28319 resultptr = new wxSize((wxSize &)(result));
28320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28329 PyObject *resultobj;
28330 wxWindow *arg1 = (wxWindow *) 0 ;
28331 int arg2 ;
28332 int arg3 ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 PyObject * obj2 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self",(char *) "x",(char *) "y", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 {
28344 arg2 = (int)(SWIG_As_int(obj1));
28345 if (SWIG_arg_fail(2)) SWIG_fail;
28346 }
28347 {
28348 arg3 = (int)(SWIG_As_int(obj2));
28349 if (SWIG_arg_fail(3)) SWIG_fail;
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 (arg1)->WarpPointer(arg2,arg3);
28354
28355 wxPyEndAllowThreads(__tstate);
28356 if (PyErr_Occurred()) SWIG_fail;
28357 }
28358 Py_INCREF(Py_None); resultobj = Py_None;
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxWindow *arg1 = (wxWindow *) 0 ;
28368 PyObject * obj0 = 0 ;
28369 char *kwnames[] = {
28370 (char *) "self", NULL
28371 };
28372
28373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28375 if (SWIG_arg_fail(1)) SWIG_fail;
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 (arg1)->CaptureMouse();
28379
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 Py_INCREF(Py_None); resultobj = Py_None;
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj;
28392 wxWindow *arg1 = (wxWindow *) 0 ;
28393 PyObject * obj0 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "self", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 (arg1)->ReleaseMouse();
28404
28405 wxPyEndAllowThreads(__tstate);
28406 if (PyErr_Occurred()) SWIG_fail;
28407 }
28408 Py_INCREF(Py_None); resultobj = Py_None;
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj;
28417 wxWindow *result;
28418 char *kwnames[] = {
28419 NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28423 {
28424 if (!wxPyCheckForApp()) SWIG_fail;
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (wxWindow *)wxWindow::GetCapture();
28427
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 {
28432 resultobj = wxPyMake_wxObject(result, 0);
28433 }
28434 return resultobj;
28435 fail:
28436 return NULL;
28437 }
28438
28439
28440 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28441 PyObject *resultobj;
28442 wxWindow *arg1 = (wxWindow *) 0 ;
28443 bool result;
28444 PyObject * obj0 = 0 ;
28445 char *kwnames[] = {
28446 (char *) "self", NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28451 if (SWIG_arg_fail(1)) SWIG_fail;
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 result = (bool)((wxWindow const *)arg1)->HasCapture();
28455
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj;
28470 wxWindow *arg1 = (wxWindow *) 0 ;
28471 bool arg2 = (bool) true ;
28472 wxRect *arg3 = (wxRect *) NULL ;
28473 PyObject * obj0 = 0 ;
28474 PyObject * obj1 = 0 ;
28475 PyObject * obj2 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 if (obj1) {
28484 {
28485 arg2 = (bool)(SWIG_As_bool(obj1));
28486 if (SWIG_arg_fail(2)) SWIG_fail;
28487 }
28488 }
28489 if (obj2) {
28490 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(3)) SWIG_fail;
28492 }
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28496
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 Py_INCREF(Py_None); resultobj = Py_None;
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj;
28509 wxWindow *arg1 = (wxWindow *) 0 ;
28510 wxRect *arg2 = 0 ;
28511 wxRect temp2 ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self",(char *) "rect", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 {
28522 arg2 = &temp2;
28523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 (arg1)->RefreshRect((wxRect const &)*arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 Py_INCREF(Py_None); resultobj = Py_None;
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj;
28541 wxWindow *arg1 = (wxWindow *) 0 ;
28542 PyObject * obj0 = 0 ;
28543 char *kwnames[] = {
28544 (char *) "self", NULL
28545 };
28546
28547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28549 if (SWIG_arg_fail(1)) SWIG_fail;
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 (arg1)->Update();
28553
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 Py_INCREF(Py_None); resultobj = Py_None;
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28565 PyObject *resultobj;
28566 wxWindow *arg1 = (wxWindow *) 0 ;
28567 PyObject * obj0 = 0 ;
28568 char *kwnames[] = {
28569 (char *) "self", NULL
28570 };
28571
28572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(1)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 (arg1)->ClearBackground();
28578
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 Py_INCREF(Py_None); resultobj = Py_None;
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28590 PyObject *resultobj;
28591 wxWindow *arg1 = (wxWindow *) 0 ;
28592 PyObject * obj0 = 0 ;
28593 char *kwnames[] = {
28594 (char *) "self", NULL
28595 };
28596
28597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28599 if (SWIG_arg_fail(1)) SWIG_fail;
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 (arg1)->Freeze();
28603
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 Py_INCREF(Py_None); resultobj = Py_None;
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxWindow *arg1 = (wxWindow *) 0 ;
28617 PyObject * obj0 = 0 ;
28618 char *kwnames[] = {
28619 (char *) "self", NULL
28620 };
28621
28622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28624 if (SWIG_arg_fail(1)) SWIG_fail;
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 (arg1)->Thaw();
28628
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 Py_INCREF(Py_None); resultobj = Py_None;
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 wxDC *arg2 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 char *kwnames[] = {
28646 (char *) "self",(char *) "dc", NULL
28647 };
28648
28649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28651 if (SWIG_arg_fail(1)) SWIG_fail;
28652 {
28653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(2)) SWIG_fail;
28655 if (arg2 == NULL) {
28656 SWIG_null_ref("wxDC");
28657 }
28658 if (SWIG_arg_fail(2)) SWIG_fail;
28659 }
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 (arg1)->PrepareDC(*arg2);
28663
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 Py_INCREF(Py_None); resultobj = Py_None;
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj;
28676 wxWindow *arg1 = (wxWindow *) 0 ;
28677 wxRegion *result;
28678 PyObject * obj0 = 0 ;
28679 char *kwnames[] = {
28680 (char *) "self", NULL
28681 };
28682
28683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28685 if (SWIG_arg_fail(1)) SWIG_fail;
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 {
28689 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28690 result = (wxRegion *) &_result_ref;
28691 }
28692
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxWindow *arg1 = (wxWindow *) 0 ;
28706 wxRect result;
28707 PyObject * obj0 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 wxRect * resultptr;
28724 resultptr = new wxRect((wxRect &)(result));
28725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28726 }
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj;
28735 wxWindow *arg1 = (wxWindow *) 0 ;
28736 int arg2 ;
28737 int arg3 ;
28738 int arg4 = (int) 1 ;
28739 int arg5 = (int) 1 ;
28740 bool result;
28741 PyObject * obj0 = 0 ;
28742 PyObject * obj1 = 0 ;
28743 PyObject * obj2 = 0 ;
28744 PyObject * obj3 = 0 ;
28745 PyObject * obj4 = 0 ;
28746 char *kwnames[] = {
28747 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28748 };
28749
28750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28752 if (SWIG_arg_fail(1)) SWIG_fail;
28753 {
28754 arg2 = (int)(SWIG_As_int(obj1));
28755 if (SWIG_arg_fail(2)) SWIG_fail;
28756 }
28757 {
28758 arg3 = (int)(SWIG_As_int(obj2));
28759 if (SWIG_arg_fail(3)) SWIG_fail;
28760 }
28761 if (obj3) {
28762 {
28763 arg4 = (int)(SWIG_As_int(obj3));
28764 if (SWIG_arg_fail(4)) SWIG_fail;
28765 }
28766 }
28767 if (obj4) {
28768 {
28769 arg5 = (int)(SWIG_As_int(obj4));
28770 if (SWIG_arg_fail(5)) SWIG_fail;
28771 }
28772 }
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj;
28791 wxWindow *arg1 = (wxWindow *) 0 ;
28792 wxPoint *arg2 = 0 ;
28793 bool result;
28794 wxPoint temp2 ;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "pt", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 {
28805 arg2 = &temp2;
28806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28807 }
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28811
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 {
28816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28817 }
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxWindow *arg1 = (wxWindow *) 0 ;
28827 wxRect *arg2 = 0 ;
28828 bool result;
28829 wxRect temp2 ;
28830 PyObject * obj0 = 0 ;
28831 PyObject * obj1 = 0 ;
28832 char *kwnames[] = {
28833 (char *) "self",(char *) "rect", NULL
28834 };
28835
28836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28838 if (SWIG_arg_fail(1)) SWIG_fail;
28839 {
28840 arg2 = &temp2;
28841 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 {
28851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj;
28861 wxWindow *arg1 = (wxWindow *) 0 ;
28862 wxVisualAttributes result;
28863 PyObject * obj0 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 {
28879 wxVisualAttributes * resultptr;
28880 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28892 wxVisualAttributes result;
28893 PyObject * obj0 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "variant", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28899 if (obj0) {
28900 {
28901 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28902 if (SWIG_arg_fail(1)) SWIG_fail;
28903 }
28904 }
28905 {
28906 if (!wxPyCheckForApp()) SWIG_fail;
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28909
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 {
28914 wxVisualAttributes * resultptr;
28915 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28917 }
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj;
28926 wxWindow *arg1 = (wxWindow *) 0 ;
28927 wxColour *arg2 = 0 ;
28928 bool result;
28929 wxColour temp2 ;
28930 PyObject * obj0 = 0 ;
28931 PyObject * obj1 = 0 ;
28932 char *kwnames[] = {
28933 (char *) "self",(char *) "colour", NULL
28934 };
28935
28936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28938 if (SWIG_arg_fail(1)) SWIG_fail;
28939 {
28940 arg2 = &temp2;
28941 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28942 }
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28946
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 {
28951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28952 }
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28960 PyObject *resultobj;
28961 wxWindow *arg1 = (wxWindow *) 0 ;
28962 wxColour *arg2 = 0 ;
28963 wxColour temp2 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 char *kwnames[] = {
28967 (char *) "self",(char *) "colour", NULL
28968 };
28969
28970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28972 if (SWIG_arg_fail(1)) SWIG_fail;
28973 {
28974 arg2 = &temp2;
28975 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28980
28981 wxPyEndAllowThreads(__tstate);
28982 if (PyErr_Occurred()) SWIG_fail;
28983 }
28984 Py_INCREF(Py_None); resultobj = Py_None;
28985 return resultobj;
28986 fail:
28987 return NULL;
28988 }
28989
28990
28991 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28992 PyObject *resultobj;
28993 wxWindow *arg1 = (wxWindow *) 0 ;
28994 wxColour *arg2 = 0 ;
28995 bool result;
28996 wxColour temp2 ;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 char *kwnames[] = {
29000 (char *) "self",(char *) "colour", NULL
29001 };
29002
29003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29005 if (SWIG_arg_fail(1)) SWIG_fail;
29006 {
29007 arg2 = &temp2;
29008 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29013
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 {
29018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29019 }
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj;
29028 wxWindow *arg1 = (wxWindow *) 0 ;
29029 wxColour *arg2 = 0 ;
29030 wxColour temp2 ;
29031 PyObject * obj0 = 0 ;
29032 PyObject * obj1 = 0 ;
29033 char *kwnames[] = {
29034 (char *) "self",(char *) "colour", NULL
29035 };
29036
29037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29039 if (SWIG_arg_fail(1)) SWIG_fail;
29040 {
29041 arg2 = &temp2;
29042 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29043 }
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 Py_INCREF(Py_None); resultobj = Py_None;
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29059 PyObject *resultobj;
29060 wxWindow *arg1 = (wxWindow *) 0 ;
29061 wxColour result;
29062 PyObject * obj0 = 0 ;
29063 char *kwnames[] = {
29064 (char *) "self", NULL
29065 };
29066
29067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29069 if (SWIG_arg_fail(1)) SWIG_fail;
29070 {
29071 PyThreadState* __tstate = wxPyBeginAllowThreads();
29072 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29073
29074 wxPyEndAllowThreads(__tstate);
29075 if (PyErr_Occurred()) SWIG_fail;
29076 }
29077 {
29078 wxColour * resultptr;
29079 resultptr = new wxColour((wxColour &)(result));
29080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29081 }
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj;
29090 wxWindow *arg1 = (wxWindow *) 0 ;
29091 wxColour result;
29092 PyObject * obj0 = 0 ;
29093 char *kwnames[] = {
29094 (char *) "self", NULL
29095 };
29096
29097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29099 if (SWIG_arg_fail(1)) SWIG_fail;
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = ((wxWindow const *)arg1)->GetForegroundColour();
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 wxColour * resultptr;
29109 resultptr = new wxColour((wxColour &)(result));
29110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29111 }
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj;
29120 wxWindow *arg1 = (wxWindow *) 0 ;
29121 wxBackgroundStyle arg2 ;
29122 bool result;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 char *kwnames[] = {
29126 (char *) "self",(char *) "style", NULL
29127 };
29128
29129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29131 if (SWIG_arg_fail(1)) SWIG_fail;
29132 {
29133 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29134 if (SWIG_arg_fail(2)) SWIG_fail;
29135 }
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29139
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 {
29144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29145 }
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj;
29154 wxWindow *arg1 = (wxWindow *) 0 ;
29155 wxBackgroundStyle result;
29156 PyObject * obj0 = 0 ;
29157 char *kwnames[] = {
29158 (char *) "self", NULL
29159 };
29160
29161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29163 if (SWIG_arg_fail(1)) SWIG_fail;
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29167
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 resultobj = SWIG_From_int((result));
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj;
29180 wxWindow *arg1 = (wxWindow *) 0 ;
29181 bool result;
29182 PyObject * obj0 = 0 ;
29183 char *kwnames[] = {
29184 (char *) "self", NULL
29185 };
29186
29187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(1)) SWIG_fail;
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = (bool)(arg1)->HasTransparentBackground();
29193
29194 wxPyEndAllowThreads(__tstate);
29195 if (PyErr_Occurred()) SWIG_fail;
29196 }
29197 {
29198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29199 }
29200 return resultobj;
29201 fail:
29202 return NULL;
29203 }
29204
29205
29206 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29207 PyObject *resultobj;
29208 wxWindow *arg1 = (wxWindow *) 0 ;
29209 wxCursor *arg2 = 0 ;
29210 bool result;
29211 PyObject * obj0 = 0 ;
29212 PyObject * obj1 = 0 ;
29213 char *kwnames[] = {
29214 (char *) "self",(char *) "cursor", NULL
29215 };
29216
29217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29219 if (SWIG_arg_fail(1)) SWIG_fail;
29220 {
29221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29222 if (SWIG_arg_fail(2)) SWIG_fail;
29223 if (arg2 == NULL) {
29224 SWIG_null_ref("wxCursor");
29225 }
29226 if (SWIG_arg_fail(2)) SWIG_fail;
29227 }
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29231
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 {
29236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29237 }
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj;
29246 wxWindow *arg1 = (wxWindow *) 0 ;
29247 wxCursor result;
29248 PyObject * obj0 = 0 ;
29249 char *kwnames[] = {
29250 (char *) "self", NULL
29251 };
29252
29253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29255 if (SWIG_arg_fail(1)) SWIG_fail;
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 result = (arg1)->GetCursor();
29259
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 {
29264 wxCursor * resultptr;
29265 resultptr = new wxCursor((wxCursor &)(result));
29266 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29267 }
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29275 PyObject *resultobj;
29276 wxWindow *arg1 = (wxWindow *) 0 ;
29277 wxFont *arg2 = 0 ;
29278 bool result;
29279 PyObject * obj0 = 0 ;
29280 PyObject * obj1 = 0 ;
29281 char *kwnames[] = {
29282 (char *) "self",(char *) "font", NULL
29283 };
29284
29285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29287 if (SWIG_arg_fail(1)) SWIG_fail;
29288 {
29289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29290 if (SWIG_arg_fail(2)) SWIG_fail;
29291 if (arg2 == NULL) {
29292 SWIG_null_ref("wxFont");
29293 }
29294 if (SWIG_arg_fail(2)) SWIG_fail;
29295 }
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29299
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 {
29304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29305 }
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj;
29314 wxWindow *arg1 = (wxWindow *) 0 ;
29315 wxFont *arg2 = 0 ;
29316 PyObject * obj0 = 0 ;
29317 PyObject * obj1 = 0 ;
29318 char *kwnames[] = {
29319 (char *) "self",(char *) "font", NULL
29320 };
29321
29322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29324 if (SWIG_arg_fail(1)) SWIG_fail;
29325 {
29326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29327 if (SWIG_arg_fail(2)) SWIG_fail;
29328 if (arg2 == NULL) {
29329 SWIG_null_ref("wxFont");
29330 }
29331 if (SWIG_arg_fail(2)) SWIG_fail;
29332 }
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 (arg1)->SetOwnFont((wxFont const &)*arg2);
29336
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 Py_INCREF(Py_None); resultobj = Py_None;
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29348 PyObject *resultobj;
29349 wxWindow *arg1 = (wxWindow *) 0 ;
29350 wxFont result;
29351 PyObject * obj0 = 0 ;
29352 char *kwnames[] = {
29353 (char *) "self", NULL
29354 };
29355
29356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29358 if (SWIG_arg_fail(1)) SWIG_fail;
29359 {
29360 PyThreadState* __tstate = wxPyBeginAllowThreads();
29361 result = (arg1)->GetFont();
29362
29363 wxPyEndAllowThreads(__tstate);
29364 if (PyErr_Occurred()) SWIG_fail;
29365 }
29366 {
29367 wxFont * resultptr;
29368 resultptr = new wxFont((wxFont &)(result));
29369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29370 }
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj;
29379 wxWindow *arg1 = (wxWindow *) 0 ;
29380 wxCaret *arg2 = (wxCaret *) 0 ;
29381 PyObject * obj0 = 0 ;
29382 PyObject * obj1 = 0 ;
29383 char *kwnames[] = {
29384 (char *) "self",(char *) "caret", NULL
29385 };
29386
29387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29389 if (SWIG_arg_fail(1)) SWIG_fail;
29390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(2)) SWIG_fail;
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 (arg1)->SetCaret(arg2);
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 Py_INCREF(Py_None); resultobj = Py_None;
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxWindow *arg1 = (wxWindow *) 0 ;
29409 wxCaret *result;
29410 PyObject * obj0 = 0 ;
29411 char *kwnames[] = {
29412 (char *) "self", NULL
29413 };
29414
29415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(1)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxWindow *arg1 = (wxWindow *) 0 ;
29435 int result;
29436 PyObject * obj0 = 0 ;
29437 char *kwnames[] = {
29438 (char *) "self", NULL
29439 };
29440
29441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29443 if (SWIG_arg_fail(1)) SWIG_fail;
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 {
29452 resultobj = SWIG_From_int((int)(result));
29453 }
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj;
29462 wxWindow *arg1 = (wxWindow *) 0 ;
29463 int result;
29464 PyObject * obj0 = 0 ;
29465 char *kwnames[] = {
29466 (char *) "self", NULL
29467 };
29468
29469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29471 if (SWIG_arg_fail(1)) SWIG_fail;
29472 {
29473 PyThreadState* __tstate = wxPyBeginAllowThreads();
29474 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29475
29476 wxPyEndAllowThreads(__tstate);
29477 if (PyErr_Occurred()) SWIG_fail;
29478 }
29479 {
29480 resultobj = SWIG_From_int((int)(result));
29481 }
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29489 PyObject *resultobj;
29490 wxWindow *arg1 = (wxWindow *) 0 ;
29491 wxString *arg2 = 0 ;
29492 int *arg3 = (int *) 0 ;
29493 int *arg4 = (int *) 0 ;
29494 bool temp2 = false ;
29495 int temp3 ;
29496 int res3 = 0 ;
29497 int temp4 ;
29498 int res4 = 0 ;
29499 PyObject * obj0 = 0 ;
29500 PyObject * obj1 = 0 ;
29501 char *kwnames[] = {
29502 (char *) "self",(char *) "string", NULL
29503 };
29504
29505 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29506 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29509 if (SWIG_arg_fail(1)) SWIG_fail;
29510 {
29511 arg2 = wxString_in_helper(obj1);
29512 if (arg2 == NULL) SWIG_fail;
29513 temp2 = true;
29514 }
29515 {
29516 PyThreadState* __tstate = wxPyBeginAllowThreads();
29517 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29518
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 Py_INCREF(Py_None); resultobj = Py_None;
29523 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29524 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29525 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29526 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29527 {
29528 if (temp2)
29529 delete arg2;
29530 }
29531 return resultobj;
29532 fail:
29533 {
29534 if (temp2)
29535 delete arg2;
29536 }
29537 return NULL;
29538 }
29539
29540
29541 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj;
29543 wxWindow *arg1 = (wxWindow *) 0 ;
29544 wxString *arg2 = 0 ;
29545 int *arg3 = (int *) 0 ;
29546 int *arg4 = (int *) 0 ;
29547 int *arg5 = (int *) 0 ;
29548 int *arg6 = (int *) 0 ;
29549 wxFont *arg7 = (wxFont *) NULL ;
29550 bool temp2 = false ;
29551 int temp3 ;
29552 int res3 = 0 ;
29553 int temp4 ;
29554 int res4 = 0 ;
29555 int temp5 ;
29556 int res5 = 0 ;
29557 int temp6 ;
29558 int res6 = 0 ;
29559 PyObject * obj0 = 0 ;
29560 PyObject * obj1 = 0 ;
29561 PyObject * obj2 = 0 ;
29562 char *kwnames[] = {
29563 (char *) "self",(char *) "string",(char *) "font", NULL
29564 };
29565
29566 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29567 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29568 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29569 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29572 if (SWIG_arg_fail(1)) SWIG_fail;
29573 {
29574 arg2 = wxString_in_helper(obj1);
29575 if (arg2 == NULL) SWIG_fail;
29576 temp2 = true;
29577 }
29578 if (obj2) {
29579 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29580 if (SWIG_arg_fail(7)) SWIG_fail;
29581 }
29582 {
29583 PyThreadState* __tstate = wxPyBeginAllowThreads();
29584 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29585
29586 wxPyEndAllowThreads(__tstate);
29587 if (PyErr_Occurred()) SWIG_fail;
29588 }
29589 Py_INCREF(Py_None); resultobj = Py_None;
29590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29591 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29592 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29593 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29594 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29595 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29596 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29597 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29598 {
29599 if (temp2)
29600 delete arg2;
29601 }
29602 return resultobj;
29603 fail:
29604 {
29605 if (temp2)
29606 delete arg2;
29607 }
29608 return NULL;
29609 }
29610
29611
29612 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj;
29614 wxWindow *arg1 = (wxWindow *) 0 ;
29615 int *arg2 = (int *) 0 ;
29616 int *arg3 = (int *) 0 ;
29617 int temp2 ;
29618 int res2 = 0 ;
29619 int temp3 ;
29620 int res3 = 0 ;
29621 PyObject * obj0 = 0 ;
29622 PyObject * obj1 = 0 ;
29623 PyObject * obj2 = 0 ;
29624 char *kwnames[] = {
29625 (char *) "self",(char *) "x",(char *) "y", NULL
29626 };
29627
29628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29630 if (SWIG_arg_fail(1)) SWIG_fail;
29631 {
29632 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29633 temp2 = SWIG_As_int(obj1);
29634 if (SWIG_arg_fail(2)) SWIG_fail;
29635 arg2 = &temp2;
29636 res2 = SWIG_NEWOBJ;
29637 }
29638 }
29639 {
29640 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29641 temp3 = SWIG_As_int(obj2);
29642 if (SWIG_arg_fail(3)) SWIG_fail;
29643 arg3 = &temp3;
29644 res3 = SWIG_NEWOBJ;
29645 }
29646 }
29647 {
29648 PyThreadState* __tstate = wxPyBeginAllowThreads();
29649 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29650
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 Py_INCREF(Py_None); resultobj = Py_None;
29655 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29656 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29657 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29658 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29666 PyObject *resultobj;
29667 wxWindow *arg1 = (wxWindow *) 0 ;
29668 int *arg2 = (int *) 0 ;
29669 int *arg3 = (int *) 0 ;
29670 int temp2 ;
29671 int res2 = 0 ;
29672 int temp3 ;
29673 int res3 = 0 ;
29674 PyObject * obj0 = 0 ;
29675 PyObject * obj1 = 0 ;
29676 PyObject * obj2 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self",(char *) "x",(char *) "y", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(1)) SWIG_fail;
29684 {
29685 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29686 temp2 = SWIG_As_int(obj1);
29687 if (SWIG_arg_fail(2)) SWIG_fail;
29688 arg2 = &temp2;
29689 res2 = SWIG_NEWOBJ;
29690 }
29691 }
29692 {
29693 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29694 temp3 = SWIG_As_int(obj2);
29695 if (SWIG_arg_fail(3)) SWIG_fail;
29696 arg3 = &temp3;
29697 res3 = SWIG_NEWOBJ;
29698 }
29699 }
29700 {
29701 PyThreadState* __tstate = wxPyBeginAllowThreads();
29702 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29703
29704 wxPyEndAllowThreads(__tstate);
29705 if (PyErr_Occurred()) SWIG_fail;
29706 }
29707 Py_INCREF(Py_None); resultobj = Py_None;
29708 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29709 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29710 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29711 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29712 return resultobj;
29713 fail:
29714 return NULL;
29715 }
29716
29717
29718 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29719 PyObject *resultobj;
29720 wxWindow *arg1 = (wxWindow *) 0 ;
29721 wxPoint *arg2 = 0 ;
29722 wxPoint result;
29723 wxPoint temp2 ;
29724 PyObject * obj0 = 0 ;
29725 PyObject * obj1 = 0 ;
29726 char *kwnames[] = {
29727 (char *) "self",(char *) "pt", NULL
29728 };
29729
29730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29732 if (SWIG_arg_fail(1)) SWIG_fail;
29733 {
29734 arg2 = &temp2;
29735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29736 }
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29740
29741 wxPyEndAllowThreads(__tstate);
29742 if (PyErr_Occurred()) SWIG_fail;
29743 }
29744 {
29745 wxPoint * resultptr;
29746 resultptr = new wxPoint((wxPoint &)(result));
29747 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29748 }
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj;
29757 wxWindow *arg1 = (wxWindow *) 0 ;
29758 wxPoint *arg2 = 0 ;
29759 wxPoint result;
29760 wxPoint temp2 ;
29761 PyObject * obj0 = 0 ;
29762 PyObject * obj1 = 0 ;
29763 char *kwnames[] = {
29764 (char *) "self",(char *) "pt", NULL
29765 };
29766
29767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29769 if (SWIG_arg_fail(1)) SWIG_fail;
29770 {
29771 arg2 = &temp2;
29772 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29773 }
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29777
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 {
29782 wxPoint * resultptr;
29783 resultptr = new wxPoint((wxPoint &)(result));
29784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29785 }
29786 return resultobj;
29787 fail:
29788 return NULL;
29789 }
29790
29791
29792 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29793 PyObject *resultobj;
29794 wxWindow *arg1 = (wxWindow *) 0 ;
29795 int arg2 ;
29796 int arg3 ;
29797 wxHitTest result;
29798 PyObject * obj0 = 0 ;
29799 PyObject * obj1 = 0 ;
29800 PyObject * obj2 = 0 ;
29801 char *kwnames[] = {
29802 (char *) "self",(char *) "x",(char *) "y", NULL
29803 };
29804
29805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29807 if (SWIG_arg_fail(1)) SWIG_fail;
29808 {
29809 arg2 = (int)(SWIG_As_int(obj1));
29810 if (SWIG_arg_fail(2)) SWIG_fail;
29811 }
29812 {
29813 arg3 = (int)(SWIG_As_int(obj2));
29814 if (SWIG_arg_fail(3)) SWIG_fail;
29815 }
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29819
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 resultobj = SWIG_From_int((result));
29824 return resultobj;
29825 fail:
29826 return NULL;
29827 }
29828
29829
29830 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29831 PyObject *resultobj;
29832 wxWindow *arg1 = (wxWindow *) 0 ;
29833 wxPoint *arg2 = 0 ;
29834 wxHitTest result;
29835 wxPoint temp2 ;
29836 PyObject * obj0 = 0 ;
29837 PyObject * obj1 = 0 ;
29838 char *kwnames[] = {
29839 (char *) "self",(char *) "pt", NULL
29840 };
29841
29842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29844 if (SWIG_arg_fail(1)) SWIG_fail;
29845 {
29846 arg2 = &temp2;
29847 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29848 }
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = SWIG_From_int((result));
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29864 PyObject *resultobj;
29865 wxWindow *arg1 = (wxWindow *) 0 ;
29866 long arg2 ;
29867 wxBorder result;
29868 PyObject * obj0 = 0 ;
29869 PyObject * obj1 = 0 ;
29870
29871 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29873 if (SWIG_arg_fail(1)) SWIG_fail;
29874 {
29875 arg2 = (long)(SWIG_As_long(obj1));
29876 if (SWIG_arg_fail(2)) SWIG_fail;
29877 }
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29881
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 resultobj = SWIG_From_int((result));
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29893 PyObject *resultobj;
29894 wxWindow *arg1 = (wxWindow *) 0 ;
29895 wxBorder result;
29896 PyObject * obj0 = 0 ;
29897
29898 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29900 if (SWIG_arg_fail(1)) SWIG_fail;
29901 {
29902 PyThreadState* __tstate = wxPyBeginAllowThreads();
29903 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29904
29905 wxPyEndAllowThreads(__tstate);
29906 if (PyErr_Occurred()) SWIG_fail;
29907 }
29908 resultobj = SWIG_From_int((result));
29909 return resultobj;
29910 fail:
29911 return NULL;
29912 }
29913
29914
29915 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29916 int argc;
29917 PyObject *argv[3];
29918 int ii;
29919
29920 argc = PyObject_Length(args);
29921 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29922 argv[ii] = PyTuple_GetItem(args,ii);
29923 }
29924 if (argc == 1) {
29925 int _v;
29926 {
29927 void *ptr;
29928 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29929 _v = 0;
29930 PyErr_Clear();
29931 } else {
29932 _v = 1;
29933 }
29934 }
29935 if (_v) {
29936 return _wrap_Window_GetBorder__SWIG_1(self,args);
29937 }
29938 }
29939 if (argc == 2) {
29940 int _v;
29941 {
29942 void *ptr;
29943 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29944 _v = 0;
29945 PyErr_Clear();
29946 } else {
29947 _v = 1;
29948 }
29949 }
29950 if (_v) {
29951 _v = SWIG_Check_long(argv[1]);
29952 if (_v) {
29953 return _wrap_Window_GetBorder__SWIG_0(self,args);
29954 }
29955 }
29956 }
29957
29958 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29959 return NULL;
29960 }
29961
29962
29963 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29964 PyObject *resultobj;
29965 wxWindow *arg1 = (wxWindow *) 0 ;
29966 long arg2 = (long) wxUPDATE_UI_NONE ;
29967 PyObject * obj0 = 0 ;
29968 PyObject * obj1 = 0 ;
29969 char *kwnames[] = {
29970 (char *) "self",(char *) "flags", NULL
29971 };
29972
29973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29975 if (SWIG_arg_fail(1)) SWIG_fail;
29976 if (obj1) {
29977 {
29978 arg2 = (long)(SWIG_As_long(obj1));
29979 if (SWIG_arg_fail(2)) SWIG_fail;
29980 }
29981 }
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 (arg1)->UpdateWindowUI(arg2);
29985
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 Py_INCREF(Py_None); resultobj = Py_None;
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj;
29998 wxWindow *arg1 = (wxWindow *) 0 ;
29999 wxMenu *arg2 = (wxMenu *) 0 ;
30000 int arg3 = (int) -1 ;
30001 int arg4 = (int) -1 ;
30002 bool result;
30003 PyObject * obj0 = 0 ;
30004 PyObject * obj1 = 0 ;
30005 PyObject * obj2 = 0 ;
30006 PyObject * obj3 = 0 ;
30007 char *kwnames[] = {
30008 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30009 };
30010
30011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30013 if (SWIG_arg_fail(1)) SWIG_fail;
30014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30015 if (SWIG_arg_fail(2)) SWIG_fail;
30016 if (obj2) {
30017 {
30018 arg3 = (int)(SWIG_As_int(obj2));
30019 if (SWIG_arg_fail(3)) SWIG_fail;
30020 }
30021 }
30022 if (obj3) {
30023 {
30024 arg4 = (int)(SWIG_As_int(obj3));
30025 if (SWIG_arg_fail(4)) SWIG_fail;
30026 }
30027 }
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 {
30036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30037 }
30038 return resultobj;
30039 fail:
30040 return NULL;
30041 }
30042
30043
30044 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30045 PyObject *resultobj;
30046 wxWindow *arg1 = (wxWindow *) 0 ;
30047 wxMenu *arg2 = (wxMenu *) 0 ;
30048 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30049 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30050 bool result;
30051 wxPoint temp3 ;
30052 PyObject * obj0 = 0 ;
30053 PyObject * obj1 = 0 ;
30054 PyObject * obj2 = 0 ;
30055 char *kwnames[] = {
30056 (char *) "self",(char *) "menu",(char *) "pos", NULL
30057 };
30058
30059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30061 if (SWIG_arg_fail(1)) SWIG_fail;
30062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(2)) SWIG_fail;
30064 if (obj2) {
30065 {
30066 arg3 = &temp3;
30067 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30068 }
30069 }
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30073
30074 wxPyEndAllowThreads(__tstate);
30075 if (PyErr_Occurred()) SWIG_fail;
30076 }
30077 {
30078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30079 }
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxWindow *arg1 = (wxWindow *) 0 ;
30089 long result;
30090 PyObject * obj0 = 0 ;
30091 char *kwnames[] = {
30092 (char *) "self", NULL
30093 };
30094
30095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(1)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (long)wxWindow_GetHandle(arg1);
30101
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 resultobj = SWIG_From_long((long)(result));
30107 }
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30115 PyObject *resultobj;
30116 wxWindow *arg1 = (wxWindow *) 0 ;
30117 long arg2 ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 char *kwnames[] = {
30121 (char *) "self",(char *) "handle", NULL
30122 };
30123
30124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30126 if (SWIG_arg_fail(1)) SWIG_fail;
30127 {
30128 arg2 = (long)(SWIG_As_long(obj1));
30129 if (SWIG_arg_fail(2)) SWIG_fail;
30130 }
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 wxWindow_AssociateHandle(arg1,arg2);
30134
30135 wxPyEndAllowThreads(__tstate);
30136 if (PyErr_Occurred()) SWIG_fail;
30137 }
30138 Py_INCREF(Py_None); resultobj = Py_None;
30139 return resultobj;
30140 fail:
30141 return NULL;
30142 }
30143
30144
30145 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30146 PyObject *resultobj;
30147 wxWindow *arg1 = (wxWindow *) 0 ;
30148 PyObject * obj0 = 0 ;
30149 char *kwnames[] = {
30150 (char *) "self", NULL
30151 };
30152
30153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(1)) SWIG_fail;
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 (arg1)->DissociateHandle();
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 Py_INCREF(Py_None); resultobj = Py_None;
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj;
30172 wxWindow *arg1 = (wxWindow *) 0 ;
30173 wxPaintEvent *arg2 = 0 ;
30174 PyObject * obj0 = 0 ;
30175 PyObject * obj1 = 0 ;
30176 char *kwnames[] = {
30177 (char *) "self",(char *) "event", NULL
30178 };
30179
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(1)) SWIG_fail;
30183 {
30184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30185 if (SWIG_arg_fail(2)) SWIG_fail;
30186 if (arg2 == NULL) {
30187 SWIG_null_ref("wxPaintEvent");
30188 }
30189 if (SWIG_arg_fail(2)) SWIG_fail;
30190 }
30191 {
30192 PyThreadState* __tstate = wxPyBeginAllowThreads();
30193 (arg1)->OnPaint(*arg2);
30194
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 Py_INCREF(Py_None); resultobj = Py_None;
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj;
30207 wxWindow *arg1 = (wxWindow *) 0 ;
30208 int arg2 ;
30209 bool result;
30210 PyObject * obj0 = 0 ;
30211 PyObject * obj1 = 0 ;
30212 char *kwnames[] = {
30213 (char *) "self",(char *) "orient", NULL
30214 };
30215
30216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30218 if (SWIG_arg_fail(1)) SWIG_fail;
30219 {
30220 arg2 = (int)(SWIG_As_int(obj1));
30221 if (SWIG_arg_fail(2)) SWIG_fail;
30222 }
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30226
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 {
30231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30232 }
30233 return resultobj;
30234 fail:
30235 return NULL;
30236 }
30237
30238
30239 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30240 PyObject *resultobj;
30241 wxWindow *arg1 = (wxWindow *) 0 ;
30242 int arg2 ;
30243 int arg3 ;
30244 int arg4 ;
30245 int arg5 ;
30246 bool arg6 = (bool) true ;
30247 PyObject * obj0 = 0 ;
30248 PyObject * obj1 = 0 ;
30249 PyObject * obj2 = 0 ;
30250 PyObject * obj3 = 0 ;
30251 PyObject * obj4 = 0 ;
30252 PyObject * obj5 = 0 ;
30253 char *kwnames[] = {
30254 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30255 };
30256
30257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30259 if (SWIG_arg_fail(1)) SWIG_fail;
30260 {
30261 arg2 = (int)(SWIG_As_int(obj1));
30262 if (SWIG_arg_fail(2)) SWIG_fail;
30263 }
30264 {
30265 arg3 = (int)(SWIG_As_int(obj2));
30266 if (SWIG_arg_fail(3)) SWIG_fail;
30267 }
30268 {
30269 arg4 = (int)(SWIG_As_int(obj3));
30270 if (SWIG_arg_fail(4)) SWIG_fail;
30271 }
30272 {
30273 arg5 = (int)(SWIG_As_int(obj4));
30274 if (SWIG_arg_fail(5)) SWIG_fail;
30275 }
30276 if (obj5) {
30277 {
30278 arg6 = (bool)(SWIG_As_bool(obj5));
30279 if (SWIG_arg_fail(6)) SWIG_fail;
30280 }
30281 }
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30285
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 Py_INCREF(Py_None); resultobj = Py_None;
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30297 PyObject *resultobj;
30298 wxWindow *arg1 = (wxWindow *) 0 ;
30299 int arg2 ;
30300 int arg3 ;
30301 bool arg4 = (bool) true ;
30302 PyObject * obj0 = 0 ;
30303 PyObject * obj1 = 0 ;
30304 PyObject * obj2 = 0 ;
30305 PyObject * obj3 = 0 ;
30306 char *kwnames[] = {
30307 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30308 };
30309
30310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30312 if (SWIG_arg_fail(1)) SWIG_fail;
30313 {
30314 arg2 = (int)(SWIG_As_int(obj1));
30315 if (SWIG_arg_fail(2)) SWIG_fail;
30316 }
30317 {
30318 arg3 = (int)(SWIG_As_int(obj2));
30319 if (SWIG_arg_fail(3)) SWIG_fail;
30320 }
30321 if (obj3) {
30322 {
30323 arg4 = (bool)(SWIG_As_bool(obj3));
30324 if (SWIG_arg_fail(4)) SWIG_fail;
30325 }
30326 }
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 (arg1)->SetScrollPos(arg2,arg3,arg4);
30330
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 Py_INCREF(Py_None); resultobj = Py_None;
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 wxWindow *arg1 = (wxWindow *) 0 ;
30344 int arg2 ;
30345 int result;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "self",(char *) "orientation", NULL
30350 };
30351
30352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30354 if (SWIG_arg_fail(1)) SWIG_fail;
30355 {
30356 arg2 = (int)(SWIG_As_int(obj1));
30357 if (SWIG_arg_fail(2)) SWIG_fail;
30358 }
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30362
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 {
30367 resultobj = SWIG_From_int((int)(result));
30368 }
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj;
30377 wxWindow *arg1 = (wxWindow *) 0 ;
30378 int arg2 ;
30379 int result;
30380 PyObject * obj0 = 0 ;
30381 PyObject * obj1 = 0 ;
30382 char *kwnames[] = {
30383 (char *) "self",(char *) "orientation", NULL
30384 };
30385
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30388 if (SWIG_arg_fail(1)) SWIG_fail;
30389 {
30390 arg2 = (int)(SWIG_As_int(obj1));
30391 if (SWIG_arg_fail(2)) SWIG_fail;
30392 }
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30396
30397 wxPyEndAllowThreads(__tstate);
30398 if (PyErr_Occurred()) SWIG_fail;
30399 }
30400 {
30401 resultobj = SWIG_From_int((int)(result));
30402 }
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30410 PyObject *resultobj;
30411 wxWindow *arg1 = (wxWindow *) 0 ;
30412 int arg2 ;
30413 int result;
30414 PyObject * obj0 = 0 ;
30415 PyObject * obj1 = 0 ;
30416 char *kwnames[] = {
30417 (char *) "self",(char *) "orientation", NULL
30418 };
30419
30420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30422 if (SWIG_arg_fail(1)) SWIG_fail;
30423 {
30424 arg2 = (int)(SWIG_As_int(obj1));
30425 if (SWIG_arg_fail(2)) SWIG_fail;
30426 }
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30430
30431 wxPyEndAllowThreads(__tstate);
30432 if (PyErr_Occurred()) SWIG_fail;
30433 }
30434 {
30435 resultobj = SWIG_From_int((int)(result));
30436 }
30437 return resultobj;
30438 fail:
30439 return NULL;
30440 }
30441
30442
30443 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30444 PyObject *resultobj;
30445 wxWindow *arg1 = (wxWindow *) 0 ;
30446 int arg2 ;
30447 int arg3 ;
30448 wxRect *arg4 = (wxRect *) NULL ;
30449 PyObject * obj0 = 0 ;
30450 PyObject * obj1 = 0 ;
30451 PyObject * obj2 = 0 ;
30452 PyObject * obj3 = 0 ;
30453 char *kwnames[] = {
30454 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30455 };
30456
30457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30459 if (SWIG_arg_fail(1)) SWIG_fail;
30460 {
30461 arg2 = (int)(SWIG_As_int(obj1));
30462 if (SWIG_arg_fail(2)) SWIG_fail;
30463 }
30464 {
30465 arg3 = (int)(SWIG_As_int(obj2));
30466 if (SWIG_arg_fail(3)) SWIG_fail;
30467 }
30468 if (obj3) {
30469 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(4)) SWIG_fail;
30471 }
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30475
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 Py_INCREF(Py_None); resultobj = Py_None;
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj;
30488 wxWindow *arg1 = (wxWindow *) 0 ;
30489 int arg2 ;
30490 bool result;
30491 PyObject * obj0 = 0 ;
30492 PyObject * obj1 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self",(char *) "lines", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 arg2 = (int)(SWIG_As_int(obj1));
30502 if (SWIG_arg_fail(2)) SWIG_fail;
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (bool)(arg1)->ScrollLines(arg2);
30507
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 {
30512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj;
30522 wxWindow *arg1 = (wxWindow *) 0 ;
30523 int arg2 ;
30524 bool result;
30525 PyObject * obj0 = 0 ;
30526 PyObject * obj1 = 0 ;
30527 char *kwnames[] = {
30528 (char *) "self",(char *) "pages", NULL
30529 };
30530
30531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30533 if (SWIG_arg_fail(1)) SWIG_fail;
30534 {
30535 arg2 = (int)(SWIG_As_int(obj1));
30536 if (SWIG_arg_fail(2)) SWIG_fail;
30537 }
30538 {
30539 PyThreadState* __tstate = wxPyBeginAllowThreads();
30540 result = (bool)(arg1)->ScrollPages(arg2);
30541
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 {
30546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30547 }
30548 return resultobj;
30549 fail:
30550 return NULL;
30551 }
30552
30553
30554 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30555 PyObject *resultobj;
30556 wxWindow *arg1 = (wxWindow *) 0 ;
30557 bool result;
30558 PyObject * obj0 = 0 ;
30559 char *kwnames[] = {
30560 (char *) "self", NULL
30561 };
30562
30563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30565 if (SWIG_arg_fail(1)) SWIG_fail;
30566 {
30567 PyThreadState* __tstate = wxPyBeginAllowThreads();
30568 result = (bool)(arg1)->LineUp();
30569
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 {
30574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30575 }
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30583 PyObject *resultobj;
30584 wxWindow *arg1 = (wxWindow *) 0 ;
30585 bool result;
30586 PyObject * obj0 = 0 ;
30587 char *kwnames[] = {
30588 (char *) "self", NULL
30589 };
30590
30591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30593 if (SWIG_arg_fail(1)) SWIG_fail;
30594 {
30595 PyThreadState* __tstate = wxPyBeginAllowThreads();
30596 result = (bool)(arg1)->LineDown();
30597
30598 wxPyEndAllowThreads(__tstate);
30599 if (PyErr_Occurred()) SWIG_fail;
30600 }
30601 {
30602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30603 }
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30611 PyObject *resultobj;
30612 wxWindow *arg1 = (wxWindow *) 0 ;
30613 bool result;
30614 PyObject * obj0 = 0 ;
30615 char *kwnames[] = {
30616 (char *) "self", NULL
30617 };
30618
30619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30621 if (SWIG_arg_fail(1)) SWIG_fail;
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (bool)(arg1)->PageUp();
30625
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 {
30630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 bool result;
30642 PyObject * obj0 = 0 ;
30643 char *kwnames[] = {
30644 (char *) "self", NULL
30645 };
30646
30647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30649 if (SWIG_arg_fail(1)) SWIG_fail;
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 result = (bool)(arg1)->PageDown();
30653
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 {
30658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30659 }
30660 return resultobj;
30661 fail:
30662 return NULL;
30663 }
30664
30665
30666 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30667 PyObject *resultobj;
30668 wxWindow *arg1 = (wxWindow *) 0 ;
30669 wxString *arg2 = 0 ;
30670 bool temp2 = false ;
30671 PyObject * obj0 = 0 ;
30672 PyObject * obj1 = 0 ;
30673 char *kwnames[] = {
30674 (char *) "self",(char *) "text", NULL
30675 };
30676
30677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30679 if (SWIG_arg_fail(1)) SWIG_fail;
30680 {
30681 arg2 = wxString_in_helper(obj1);
30682 if (arg2 == NULL) SWIG_fail;
30683 temp2 = true;
30684 }
30685 {
30686 PyThreadState* __tstate = wxPyBeginAllowThreads();
30687 (arg1)->SetHelpText((wxString const &)*arg2);
30688
30689 wxPyEndAllowThreads(__tstate);
30690 if (PyErr_Occurred()) SWIG_fail;
30691 }
30692 Py_INCREF(Py_None); resultobj = Py_None;
30693 {
30694 if (temp2)
30695 delete arg2;
30696 }
30697 return resultobj;
30698 fail:
30699 {
30700 if (temp2)
30701 delete arg2;
30702 }
30703 return NULL;
30704 }
30705
30706
30707 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30708 PyObject *resultobj;
30709 wxWindow *arg1 = (wxWindow *) 0 ;
30710 wxString *arg2 = 0 ;
30711 bool temp2 = false ;
30712 PyObject * obj0 = 0 ;
30713 PyObject * obj1 = 0 ;
30714 char *kwnames[] = {
30715 (char *) "self",(char *) "text", NULL
30716 };
30717
30718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30720 if (SWIG_arg_fail(1)) SWIG_fail;
30721 {
30722 arg2 = wxString_in_helper(obj1);
30723 if (arg2 == NULL) SWIG_fail;
30724 temp2 = true;
30725 }
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30729
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 Py_INCREF(Py_None); resultobj = Py_None;
30734 {
30735 if (temp2)
30736 delete arg2;
30737 }
30738 return resultobj;
30739 fail:
30740 {
30741 if (temp2)
30742 delete arg2;
30743 }
30744 return NULL;
30745 }
30746
30747
30748 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30749 PyObject *resultobj;
30750 wxWindow *arg1 = (wxWindow *) 0 ;
30751 wxString result;
30752 PyObject * obj0 = 0 ;
30753 char *kwnames[] = {
30754 (char *) "self", NULL
30755 };
30756
30757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30759 if (SWIG_arg_fail(1)) SWIG_fail;
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 result = ((wxWindow const *)arg1)->GetHelpText();
30763
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 {
30768 #if wxUSE_UNICODE
30769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30770 #else
30771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30772 #endif
30773 }
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxString *arg2 = 0 ;
30784 bool temp2 = false ;
30785 PyObject * obj0 = 0 ;
30786 PyObject * obj1 = 0 ;
30787 char *kwnames[] = {
30788 (char *) "self",(char *) "tip", NULL
30789 };
30790
30791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30793 if (SWIG_arg_fail(1)) SWIG_fail;
30794 {
30795 arg2 = wxString_in_helper(obj1);
30796 if (arg2 == NULL) SWIG_fail;
30797 temp2 = true;
30798 }
30799 {
30800 PyThreadState* __tstate = wxPyBeginAllowThreads();
30801 (arg1)->SetToolTip((wxString const &)*arg2);
30802
30803 wxPyEndAllowThreads(__tstate);
30804 if (PyErr_Occurred()) SWIG_fail;
30805 }
30806 Py_INCREF(Py_None); resultobj = Py_None;
30807 {
30808 if (temp2)
30809 delete arg2;
30810 }
30811 return resultobj;
30812 fail:
30813 {
30814 if (temp2)
30815 delete arg2;
30816 }
30817 return NULL;
30818 }
30819
30820
30821 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30822 PyObject *resultobj;
30823 wxWindow *arg1 = (wxWindow *) 0 ;
30824 wxToolTip *arg2 = (wxToolTip *) 0 ;
30825 PyObject * obj0 = 0 ;
30826 PyObject * obj1 = 0 ;
30827 char *kwnames[] = {
30828 (char *) "self",(char *) "tip", NULL
30829 };
30830
30831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30833 if (SWIG_arg_fail(1)) SWIG_fail;
30834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30835 if (SWIG_arg_fail(2)) SWIG_fail;
30836 {
30837 PyThreadState* __tstate = wxPyBeginAllowThreads();
30838 (arg1)->SetToolTip(arg2);
30839
30840 wxPyEndAllowThreads(__tstate);
30841 if (PyErr_Occurred()) SWIG_fail;
30842 }
30843 Py_INCREF(Py_None); resultobj = Py_None;
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30851 PyObject *resultobj;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 wxToolTip *result;
30854 PyObject * obj0 = 0 ;
30855 char *kwnames[] = {
30856 (char *) "self", NULL
30857 };
30858
30859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30861 if (SWIG_arg_fail(1)) SWIG_fail;
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30865
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 {
30870 resultobj = wxPyMake_wxObject(result, 0);
30871 }
30872 return resultobj;
30873 fail:
30874 return NULL;
30875 }
30876
30877
30878 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30879 PyObject *resultobj;
30880 wxWindow *arg1 = (wxWindow *) 0 ;
30881 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 char *kwnames[] = {
30885 (char *) "self",(char *) "dropTarget", NULL
30886 };
30887
30888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30890 if (SWIG_arg_fail(1)) SWIG_fail;
30891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30892 if (SWIG_arg_fail(2)) SWIG_fail;
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 (arg1)->SetDropTarget(arg2);
30896
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 Py_INCREF(Py_None); resultobj = Py_None;
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30908 PyObject *resultobj;
30909 wxWindow *arg1 = (wxWindow *) 0 ;
30910 wxPyDropTarget *result;
30911 PyObject * obj0 = 0 ;
30912 char *kwnames[] = {
30913 (char *) "self", NULL
30914 };
30915
30916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30918 if (SWIG_arg_fail(1)) SWIG_fail;
30919 {
30920 PyThreadState* __tstate = wxPyBeginAllowThreads();
30921 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30922
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 bool arg2 ;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char *kwnames[] = {
30940 (char *) "self",(char *) "accept", NULL
30941 };
30942
30943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
30944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30945 if (SWIG_arg_fail(1)) SWIG_fail;
30946 {
30947 arg2 = (bool)(SWIG_As_bool(obj1));
30948 if (SWIG_arg_fail(2)) SWIG_fail;
30949 }
30950 {
30951 PyThreadState* __tstate = wxPyBeginAllowThreads();
30952 (arg1)->DragAcceptFiles(arg2);
30953
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 Py_INCREF(Py_None); resultobj = Py_None;
30958 return resultobj;
30959 fail:
30960 return NULL;
30961 }
30962
30963
30964 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30965 PyObject *resultobj;
30966 wxWindow *arg1 = (wxWindow *) 0 ;
30967 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30968 PyObject * obj0 = 0 ;
30969 PyObject * obj1 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "self",(char *) "constraints", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30976 if (SWIG_arg_fail(1)) SWIG_fail;
30977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(2)) SWIG_fail;
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 (arg1)->SetConstraints(arg2);
30982
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 Py_INCREF(Py_None); resultobj = Py_None;
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 wxLayoutConstraints *result;
30997 PyObject * obj0 = 0 ;
30998 char *kwnames[] = {
30999 (char *) "self", NULL
31000 };
31001
31002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31004 if (SWIG_arg_fail(1)) SWIG_fail;
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31008
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31020 PyObject *resultobj;
31021 wxWindow *arg1 = (wxWindow *) 0 ;
31022 bool arg2 ;
31023 PyObject * obj0 = 0 ;
31024 PyObject * obj1 = 0 ;
31025 char *kwnames[] = {
31026 (char *) "self",(char *) "autoLayout", NULL
31027 };
31028
31029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31031 if (SWIG_arg_fail(1)) SWIG_fail;
31032 {
31033 arg2 = (bool)(SWIG_As_bool(obj1));
31034 if (SWIG_arg_fail(2)) SWIG_fail;
31035 }
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 (arg1)->SetAutoLayout(arg2);
31039
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 Py_INCREF(Py_None); resultobj = Py_None;
31044 return resultobj;
31045 fail:
31046 return NULL;
31047 }
31048
31049
31050 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31051 PyObject *resultobj;
31052 wxWindow *arg1 = (wxWindow *) 0 ;
31053 bool result;
31054 PyObject * obj0 = 0 ;
31055 char *kwnames[] = {
31056 (char *) "self", NULL
31057 };
31058
31059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31061 if (SWIG_arg_fail(1)) SWIG_fail;
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31065
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 {
31070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31071 }
31072 return resultobj;
31073 fail:
31074 return NULL;
31075 }
31076
31077
31078 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31079 PyObject *resultobj;
31080 wxWindow *arg1 = (wxWindow *) 0 ;
31081 bool result;
31082 PyObject * obj0 = 0 ;
31083 char *kwnames[] = {
31084 (char *) "self", NULL
31085 };
31086
31087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31089 if (SWIG_arg_fail(1)) SWIG_fail;
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 result = (bool)(arg1)->Layout();
31093
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 {
31098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31099 }
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31107 PyObject *resultobj;
31108 wxWindow *arg1 = (wxWindow *) 0 ;
31109 wxSizer *arg2 = (wxSizer *) 0 ;
31110 bool arg3 = (bool) true ;
31111 PyObject * obj0 = 0 ;
31112 PyObject * obj1 = 0 ;
31113 PyObject * obj2 = 0 ;
31114 char *kwnames[] = {
31115 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31116 };
31117
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31122 if (SWIG_arg_fail(2)) SWIG_fail;
31123 if (obj2) {
31124 {
31125 arg3 = (bool)(SWIG_As_bool(obj2));
31126 if (SWIG_arg_fail(3)) SWIG_fail;
31127 }
31128 }
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 (arg1)->SetSizer(arg2,arg3);
31132
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 Py_INCREF(Py_None); resultobj = Py_None;
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31144 PyObject *resultobj;
31145 wxWindow *arg1 = (wxWindow *) 0 ;
31146 wxSizer *arg2 = (wxSizer *) 0 ;
31147 bool arg3 = (bool) true ;
31148 PyObject * obj0 = 0 ;
31149 PyObject * obj1 = 0 ;
31150 PyObject * obj2 = 0 ;
31151 char *kwnames[] = {
31152 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31153 };
31154
31155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31157 if (SWIG_arg_fail(1)) SWIG_fail;
31158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31159 if (SWIG_arg_fail(2)) SWIG_fail;
31160 if (obj2) {
31161 {
31162 arg3 = (bool)(SWIG_As_bool(obj2));
31163 if (SWIG_arg_fail(3)) SWIG_fail;
31164 }
31165 }
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 (arg1)->SetSizerAndFit(arg2,arg3);
31169
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 Py_INCREF(Py_None); resultobj = Py_None;
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 wxSizer *result;
31184 PyObject * obj0 = 0 ;
31185 char *kwnames[] = {
31186 (char *) "self", NULL
31187 };
31188
31189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31191 if (SWIG_arg_fail(1)) SWIG_fail;
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 resultobj = wxPyMake_wxSizer(result, 0);
31201 }
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 wxSizer *arg2 = (wxSizer *) 0 ;
31212 PyObject * obj0 = 0 ;
31213 PyObject * obj1 = 0 ;
31214 char *kwnames[] = {
31215 (char *) "self",(char *) "sizer", NULL
31216 };
31217
31218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31220 if (SWIG_arg_fail(1)) SWIG_fail;
31221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31222 if (SWIG_arg_fail(2)) SWIG_fail;
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 (arg1)->SetContainingSizer(arg2);
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 Py_INCREF(Py_None); resultobj = Py_None;
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj;
31239 wxWindow *arg1 = (wxWindow *) 0 ;
31240 wxSizer *result;
31241 PyObject * obj0 = 0 ;
31242 char *kwnames[] = {
31243 (char *) "self", NULL
31244 };
31245
31246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31248 if (SWIG_arg_fail(1)) SWIG_fail;
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31252
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 {
31257 resultobj = wxPyMake_wxSizer(result, 0);
31258 }
31259 return resultobj;
31260 fail:
31261 return NULL;
31262 }
31263
31264
31265 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31266 PyObject *resultobj;
31267 wxWindow *arg1 = (wxWindow *) 0 ;
31268 PyObject * obj0 = 0 ;
31269 char *kwnames[] = {
31270 (char *) "self", NULL
31271 };
31272
31273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31275 if (SWIG_arg_fail(1)) SWIG_fail;
31276 {
31277 PyThreadState* __tstate = wxPyBeginAllowThreads();
31278 (arg1)->InheritAttributes();
31279
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 Py_INCREF(Py_None); resultobj = Py_None;
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31291 PyObject *resultobj;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 bool result;
31294 PyObject * obj0 = 0 ;
31295 char *kwnames[] = {
31296 (char *) "self", NULL
31297 };
31298
31299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31301 if (SWIG_arg_fail(1)) SWIG_fail;
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31305
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 {
31310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31311 }
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31319 PyObject *obj;
31320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31321 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31322 Py_INCREF(obj);
31323 return Py_BuildValue((char *)"");
31324 }
31325 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31326 PyObject *resultobj;
31327 long arg1 ;
31328 wxWindow *arg2 = (wxWindow *) NULL ;
31329 wxWindow *result;
31330 PyObject * obj0 = 0 ;
31331 PyObject * obj1 = 0 ;
31332 char *kwnames[] = {
31333 (char *) "id",(char *) "parent", NULL
31334 };
31335
31336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31337 {
31338 arg1 = (long)(SWIG_As_long(obj0));
31339 if (SWIG_arg_fail(1)) SWIG_fail;
31340 }
31341 if (obj1) {
31342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31343 if (SWIG_arg_fail(2)) SWIG_fail;
31344 }
31345 {
31346 if (!wxPyCheckForApp()) SWIG_fail;
31347 PyThreadState* __tstate = wxPyBeginAllowThreads();
31348 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31349
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 {
31354 resultobj = wxPyMake_wxObject(result, 0);
31355 }
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31363 PyObject *resultobj;
31364 wxString *arg1 = 0 ;
31365 wxWindow *arg2 = (wxWindow *) NULL ;
31366 wxWindow *result;
31367 bool temp1 = false ;
31368 PyObject * obj0 = 0 ;
31369 PyObject * obj1 = 0 ;
31370 char *kwnames[] = {
31371 (char *) "name",(char *) "parent", NULL
31372 };
31373
31374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31375 {
31376 arg1 = wxString_in_helper(obj0);
31377 if (arg1 == NULL) SWIG_fail;
31378 temp1 = true;
31379 }
31380 if (obj1) {
31381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31382 if (SWIG_arg_fail(2)) SWIG_fail;
31383 }
31384 {
31385 if (!wxPyCheckForApp()) SWIG_fail;
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31388
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 resultobj = wxPyMake_wxObject(result, 0);
31394 }
31395 {
31396 if (temp1)
31397 delete arg1;
31398 }
31399 return resultobj;
31400 fail:
31401 {
31402 if (temp1)
31403 delete arg1;
31404 }
31405 return NULL;
31406 }
31407
31408
31409 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31410 PyObject *resultobj;
31411 wxString *arg1 = 0 ;
31412 wxWindow *arg2 = (wxWindow *) NULL ;
31413 wxWindow *result;
31414 bool temp1 = false ;
31415 PyObject * obj0 = 0 ;
31416 PyObject * obj1 = 0 ;
31417 char *kwnames[] = {
31418 (char *) "label",(char *) "parent", NULL
31419 };
31420
31421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31422 {
31423 arg1 = wxString_in_helper(obj0);
31424 if (arg1 == NULL) SWIG_fail;
31425 temp1 = true;
31426 }
31427 if (obj1) {
31428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31429 if (SWIG_arg_fail(2)) SWIG_fail;
31430 }
31431 {
31432 if (!wxPyCheckForApp()) SWIG_fail;
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31435
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 {
31440 resultobj = wxPyMake_wxObject(result, 0);
31441 }
31442 {
31443 if (temp1)
31444 delete arg1;
31445 }
31446 return resultobj;
31447 fail:
31448 {
31449 if (temp1)
31450 delete arg1;
31451 }
31452 return NULL;
31453 }
31454
31455
31456 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 unsigned long arg2 ;
31460 wxWindow *result;
31461 PyObject * obj0 = 0 ;
31462 PyObject * obj1 = 0 ;
31463 char *kwnames[] = {
31464 (char *) "parent",(char *) "_hWnd", NULL
31465 };
31466
31467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31469 if (SWIG_arg_fail(1)) SWIG_fail;
31470 {
31471 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31472 if (SWIG_arg_fail(2)) SWIG_fail;
31473 }
31474 {
31475 PyThreadState* __tstate = wxPyBeginAllowThreads();
31476 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31477
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 {
31482 resultobj = wxPyMake_wxObject(result, 0);
31483 }
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj;
31492 wxValidator *result;
31493 char *kwnames[] = {
31494 NULL
31495 };
31496
31497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (wxValidator *)new wxValidator();
31501
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj;
31514 wxValidator *arg1 = (wxValidator *) 0 ;
31515 wxValidator *result;
31516 PyObject * obj0 = 0 ;
31517 char *kwnames[] = {
31518 (char *) "self", NULL
31519 };
31520
31521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31523 if (SWIG_arg_fail(1)) SWIG_fail;
31524 {
31525 PyThreadState* __tstate = wxPyBeginAllowThreads();
31526 result = (wxValidator *)(arg1)->Clone();
31527
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 {
31532 resultobj = wxPyMake_wxObject(result, 0);
31533 }
31534 return resultobj;
31535 fail:
31536 return NULL;
31537 }
31538
31539
31540 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31541 PyObject *resultobj;
31542 wxValidator *arg1 = (wxValidator *) 0 ;
31543 wxWindow *arg2 = (wxWindow *) 0 ;
31544 bool result;
31545 PyObject * obj0 = 0 ;
31546 PyObject * obj1 = 0 ;
31547 char *kwnames[] = {
31548 (char *) "self",(char *) "parent", NULL
31549 };
31550
31551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31553 if (SWIG_arg_fail(1)) SWIG_fail;
31554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31555 if (SWIG_arg_fail(2)) SWIG_fail;
31556 {
31557 PyThreadState* __tstate = wxPyBeginAllowThreads();
31558 result = (bool)(arg1)->Validate(arg2);
31559
31560 wxPyEndAllowThreads(__tstate);
31561 if (PyErr_Occurred()) SWIG_fail;
31562 }
31563 {
31564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31565 }
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31573 PyObject *resultobj;
31574 wxValidator *arg1 = (wxValidator *) 0 ;
31575 bool result;
31576 PyObject * obj0 = 0 ;
31577 char *kwnames[] = {
31578 (char *) "self", NULL
31579 };
31580
31581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31583 if (SWIG_arg_fail(1)) SWIG_fail;
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = (bool)(arg1)->TransferToWindow();
31587
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 {
31592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31593 }
31594 return resultobj;
31595 fail:
31596 return NULL;
31597 }
31598
31599
31600 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31601 PyObject *resultobj;
31602 wxValidator *arg1 = (wxValidator *) 0 ;
31603 bool result;
31604 PyObject * obj0 = 0 ;
31605 char *kwnames[] = {
31606 (char *) "self", NULL
31607 };
31608
31609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31611 if (SWIG_arg_fail(1)) SWIG_fail;
31612 {
31613 PyThreadState* __tstate = wxPyBeginAllowThreads();
31614 result = (bool)(arg1)->TransferFromWindow();
31615
31616 wxPyEndAllowThreads(__tstate);
31617 if (PyErr_Occurred()) SWIG_fail;
31618 }
31619 {
31620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31621 }
31622 return resultobj;
31623 fail:
31624 return NULL;
31625 }
31626
31627
31628 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31629 PyObject *resultobj;
31630 wxValidator *arg1 = (wxValidator *) 0 ;
31631 wxWindow *result;
31632 PyObject * obj0 = 0 ;
31633 char *kwnames[] = {
31634 (char *) "self", NULL
31635 };
31636
31637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31639 if (SWIG_arg_fail(1)) SWIG_fail;
31640 {
31641 PyThreadState* __tstate = wxPyBeginAllowThreads();
31642 result = (wxWindow *)(arg1)->GetWindow();
31643
31644 wxPyEndAllowThreads(__tstate);
31645 if (PyErr_Occurred()) SWIG_fail;
31646 }
31647 {
31648 resultobj = wxPyMake_wxObject(result, 0);
31649 }
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31657 PyObject *resultobj;
31658 wxValidator *arg1 = (wxValidator *) 0 ;
31659 wxWindow *arg2 = (wxWindow *) 0 ;
31660 PyObject * obj0 = 0 ;
31661 PyObject * obj1 = 0 ;
31662 char *kwnames[] = {
31663 (char *) "self",(char *) "window", NULL
31664 };
31665
31666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31668 if (SWIG_arg_fail(1)) SWIG_fail;
31669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31670 if (SWIG_arg_fail(2)) SWIG_fail;
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 (arg1)->SetWindow(arg2);
31674
31675 wxPyEndAllowThreads(__tstate);
31676 if (PyErr_Occurred()) SWIG_fail;
31677 }
31678 Py_INCREF(Py_None); resultobj = Py_None;
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31686 PyObject *resultobj;
31687 bool result;
31688 char *kwnames[] = {
31689 NULL
31690 };
31691
31692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31693 {
31694 PyThreadState* __tstate = wxPyBeginAllowThreads();
31695 result = (bool)wxValidator::IsSilent();
31696
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 {
31701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31702 }
31703 return resultobj;
31704 fail:
31705 return NULL;
31706 }
31707
31708
31709 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31710 PyObject *resultobj;
31711 int arg1 = (int) true ;
31712 PyObject * obj0 = 0 ;
31713 char *kwnames[] = {
31714 (char *) "doIt", NULL
31715 };
31716
31717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31718 if (obj0) {
31719 {
31720 arg1 = (int)(SWIG_As_int(obj0));
31721 if (SWIG_arg_fail(1)) SWIG_fail;
31722 }
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 wxValidator::SetBellOnError(arg1);
31727
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 Py_INCREF(Py_None); resultobj = Py_None;
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31739 PyObject *obj;
31740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31741 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31742 Py_INCREF(obj);
31743 return Py_BuildValue((char *)"");
31744 }
31745 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj;
31747 wxPyValidator *result;
31748 char *kwnames[] = {
31749 NULL
31750 };
31751
31752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31753 {
31754 PyThreadState* __tstate = wxPyBeginAllowThreads();
31755 result = (wxPyValidator *)new wxPyValidator();
31756
31757 wxPyEndAllowThreads(__tstate);
31758 if (PyErr_Occurred()) SWIG_fail;
31759 }
31760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31761 return resultobj;
31762 fail:
31763 return NULL;
31764 }
31765
31766
31767 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31768 PyObject *resultobj;
31769 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31770 PyObject *arg2 = (PyObject *) 0 ;
31771 PyObject *arg3 = (PyObject *) 0 ;
31772 int arg4 = (int) true ;
31773 PyObject * obj0 = 0 ;
31774 PyObject * obj1 = 0 ;
31775 PyObject * obj2 = 0 ;
31776 PyObject * obj3 = 0 ;
31777 char *kwnames[] = {
31778 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31779 };
31780
31781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31783 if (SWIG_arg_fail(1)) SWIG_fail;
31784 arg2 = obj1;
31785 arg3 = obj2;
31786 if (obj3) {
31787 {
31788 arg4 = (int)(SWIG_As_int(obj3));
31789 if (SWIG_arg_fail(4)) SWIG_fail;
31790 }
31791 }
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31795
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 Py_INCREF(Py_None); resultobj = Py_None;
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31807 PyObject *obj;
31808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31809 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31810 Py_INCREF(obj);
31811 return Py_BuildValue((char *)"");
31812 }
31813 static int _wrap_DefaultValidator_set(PyObject *) {
31814 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31815 return 1;
31816 }
31817
31818
31819 static PyObject *_wrap_DefaultValidator_get(void) {
31820 PyObject *pyobj;
31821
31822 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31823 return pyobj;
31824 }
31825
31826
31827 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31828 PyObject *resultobj;
31829 wxString const &arg1_defvalue = wxPyEmptyString ;
31830 wxString *arg1 = (wxString *) &arg1_defvalue ;
31831 long arg2 = (long) 0 ;
31832 wxMenu *result;
31833 bool temp1 = false ;
31834 PyObject * obj0 = 0 ;
31835 PyObject * obj1 = 0 ;
31836 char *kwnames[] = {
31837 (char *) "title",(char *) "style", NULL
31838 };
31839
31840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31841 if (obj0) {
31842 {
31843 arg1 = wxString_in_helper(obj0);
31844 if (arg1 == NULL) SWIG_fail;
31845 temp1 = true;
31846 }
31847 }
31848 if (obj1) {
31849 {
31850 arg2 = (long)(SWIG_As_long(obj1));
31851 if (SWIG_arg_fail(2)) SWIG_fail;
31852 }
31853 }
31854 {
31855 if (!wxPyCheckForApp()) SWIG_fail;
31856 PyThreadState* __tstate = wxPyBeginAllowThreads();
31857 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31858
31859 wxPyEndAllowThreads(__tstate);
31860 if (PyErr_Occurred()) SWIG_fail;
31861 }
31862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31863 {
31864 if (temp1)
31865 delete arg1;
31866 }
31867 return resultobj;
31868 fail:
31869 {
31870 if (temp1)
31871 delete arg1;
31872 }
31873 return NULL;
31874 }
31875
31876
31877 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31878 PyObject *resultobj;
31879 wxMenu *arg1 = (wxMenu *) 0 ;
31880 int arg2 ;
31881 wxString *arg3 = 0 ;
31882 wxString const &arg4_defvalue = wxPyEmptyString ;
31883 wxString *arg4 = (wxString *) &arg4_defvalue ;
31884 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31885 wxMenuItem *result;
31886 bool temp3 = false ;
31887 bool temp4 = false ;
31888 PyObject * obj0 = 0 ;
31889 PyObject * obj1 = 0 ;
31890 PyObject * obj2 = 0 ;
31891 PyObject * obj3 = 0 ;
31892 PyObject * obj4 = 0 ;
31893 char *kwnames[] = {
31894 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31895 };
31896
31897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31899 if (SWIG_arg_fail(1)) SWIG_fail;
31900 {
31901 arg2 = (int)(SWIG_As_int(obj1));
31902 if (SWIG_arg_fail(2)) SWIG_fail;
31903 }
31904 {
31905 arg3 = wxString_in_helper(obj2);
31906 if (arg3 == NULL) SWIG_fail;
31907 temp3 = true;
31908 }
31909 if (obj3) {
31910 {
31911 arg4 = wxString_in_helper(obj3);
31912 if (arg4 == NULL) SWIG_fail;
31913 temp4 = true;
31914 }
31915 }
31916 if (obj4) {
31917 {
31918 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31919 if (SWIG_arg_fail(5)) SWIG_fail;
31920 }
31921 }
31922 {
31923 PyThreadState* __tstate = wxPyBeginAllowThreads();
31924 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31925
31926 wxPyEndAllowThreads(__tstate);
31927 if (PyErr_Occurred()) SWIG_fail;
31928 }
31929 {
31930 resultobj = wxPyMake_wxObject(result, 0);
31931 }
31932 {
31933 if (temp3)
31934 delete arg3;
31935 }
31936 {
31937 if (temp4)
31938 delete arg4;
31939 }
31940 return resultobj;
31941 fail:
31942 {
31943 if (temp3)
31944 delete arg3;
31945 }
31946 {
31947 if (temp4)
31948 delete arg4;
31949 }
31950 return NULL;
31951 }
31952
31953
31954 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31955 PyObject *resultobj;
31956 wxMenu *arg1 = (wxMenu *) 0 ;
31957 wxMenuItem *result;
31958 PyObject * obj0 = 0 ;
31959 char *kwnames[] = {
31960 (char *) "self", NULL
31961 };
31962
31963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31965 if (SWIG_arg_fail(1)) SWIG_fail;
31966 {
31967 PyThreadState* __tstate = wxPyBeginAllowThreads();
31968 result = (wxMenuItem *)(arg1)->AppendSeparator();
31969
31970 wxPyEndAllowThreads(__tstate);
31971 if (PyErr_Occurred()) SWIG_fail;
31972 }
31973 {
31974 resultobj = wxPyMake_wxObject(result, 0);
31975 }
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31983 PyObject *resultobj;
31984 wxMenu *arg1 = (wxMenu *) 0 ;
31985 int arg2 ;
31986 wxString *arg3 = 0 ;
31987 wxString const &arg4_defvalue = wxPyEmptyString ;
31988 wxString *arg4 = (wxString *) &arg4_defvalue ;
31989 wxMenuItem *result;
31990 bool temp3 = false ;
31991 bool temp4 = false ;
31992 PyObject * obj0 = 0 ;
31993 PyObject * obj1 = 0 ;
31994 PyObject * obj2 = 0 ;
31995 PyObject * obj3 = 0 ;
31996 char *kwnames[] = {
31997 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31998 };
31999
32000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32002 if (SWIG_arg_fail(1)) SWIG_fail;
32003 {
32004 arg2 = (int)(SWIG_As_int(obj1));
32005 if (SWIG_arg_fail(2)) SWIG_fail;
32006 }
32007 {
32008 arg3 = wxString_in_helper(obj2);
32009 if (arg3 == NULL) SWIG_fail;
32010 temp3 = true;
32011 }
32012 if (obj3) {
32013 {
32014 arg4 = wxString_in_helper(obj3);
32015 if (arg4 == NULL) SWIG_fail;
32016 temp4 = true;
32017 }
32018 }
32019 {
32020 PyThreadState* __tstate = wxPyBeginAllowThreads();
32021 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32022
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 {
32027 resultobj = wxPyMake_wxObject(result, 0);
32028 }
32029 {
32030 if (temp3)
32031 delete arg3;
32032 }
32033 {
32034 if (temp4)
32035 delete arg4;
32036 }
32037 return resultobj;
32038 fail:
32039 {
32040 if (temp3)
32041 delete arg3;
32042 }
32043 {
32044 if (temp4)
32045 delete arg4;
32046 }
32047 return NULL;
32048 }
32049
32050
32051 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32052 PyObject *resultobj;
32053 wxMenu *arg1 = (wxMenu *) 0 ;
32054 int arg2 ;
32055 wxString *arg3 = 0 ;
32056 wxString const &arg4_defvalue = wxPyEmptyString ;
32057 wxString *arg4 = (wxString *) &arg4_defvalue ;
32058 wxMenuItem *result;
32059 bool temp3 = false ;
32060 bool temp4 = false ;
32061 PyObject * obj0 = 0 ;
32062 PyObject * obj1 = 0 ;
32063 PyObject * obj2 = 0 ;
32064 PyObject * obj3 = 0 ;
32065 char *kwnames[] = {
32066 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32067 };
32068
32069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32071 if (SWIG_arg_fail(1)) SWIG_fail;
32072 {
32073 arg2 = (int)(SWIG_As_int(obj1));
32074 if (SWIG_arg_fail(2)) SWIG_fail;
32075 }
32076 {
32077 arg3 = wxString_in_helper(obj2);
32078 if (arg3 == NULL) SWIG_fail;
32079 temp3 = true;
32080 }
32081 if (obj3) {
32082 {
32083 arg4 = wxString_in_helper(obj3);
32084 if (arg4 == NULL) SWIG_fail;
32085 temp4 = true;
32086 }
32087 }
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32091
32092 wxPyEndAllowThreads(__tstate);
32093 if (PyErr_Occurred()) SWIG_fail;
32094 }
32095 {
32096 resultobj = wxPyMake_wxObject(result, 0);
32097 }
32098 {
32099 if (temp3)
32100 delete arg3;
32101 }
32102 {
32103 if (temp4)
32104 delete arg4;
32105 }
32106 return resultobj;
32107 fail:
32108 {
32109 if (temp3)
32110 delete arg3;
32111 }
32112 {
32113 if (temp4)
32114 delete arg4;
32115 }
32116 return NULL;
32117 }
32118
32119
32120 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32121 PyObject *resultobj;
32122 wxMenu *arg1 = (wxMenu *) 0 ;
32123 int arg2 ;
32124 wxString *arg3 = 0 ;
32125 wxMenu *arg4 = (wxMenu *) 0 ;
32126 wxString const &arg5_defvalue = wxPyEmptyString ;
32127 wxString *arg5 = (wxString *) &arg5_defvalue ;
32128 wxMenuItem *result;
32129 bool temp3 = false ;
32130 bool temp5 = false ;
32131 PyObject * obj0 = 0 ;
32132 PyObject * obj1 = 0 ;
32133 PyObject * obj2 = 0 ;
32134 PyObject * obj3 = 0 ;
32135 PyObject * obj4 = 0 ;
32136 char *kwnames[] = {
32137 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32138 };
32139
32140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32142 if (SWIG_arg_fail(1)) SWIG_fail;
32143 {
32144 arg2 = (int)(SWIG_As_int(obj1));
32145 if (SWIG_arg_fail(2)) SWIG_fail;
32146 }
32147 {
32148 arg3 = wxString_in_helper(obj2);
32149 if (arg3 == NULL) SWIG_fail;
32150 temp3 = true;
32151 }
32152 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32153 if (SWIG_arg_fail(4)) SWIG_fail;
32154 if (obj4) {
32155 {
32156 arg5 = wxString_in_helper(obj4);
32157 if (arg5 == NULL) SWIG_fail;
32158 temp5 = true;
32159 }
32160 }
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32164
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 {
32169 resultobj = wxPyMake_wxObject(result, 0);
32170 }
32171 {
32172 if (temp3)
32173 delete arg3;
32174 }
32175 {
32176 if (temp5)
32177 delete arg5;
32178 }
32179 return resultobj;
32180 fail:
32181 {
32182 if (temp3)
32183 delete arg3;
32184 }
32185 {
32186 if (temp5)
32187 delete arg5;
32188 }
32189 return NULL;
32190 }
32191
32192
32193 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32194 PyObject *resultobj;
32195 wxMenu *arg1 = (wxMenu *) 0 ;
32196 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32197 wxMenuItem *result;
32198 PyObject * obj0 = 0 ;
32199 PyObject * obj1 = 0 ;
32200 char *kwnames[] = {
32201 (char *) "self",(char *) "item", NULL
32202 };
32203
32204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32206 if (SWIG_arg_fail(1)) SWIG_fail;
32207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32208 if (SWIG_arg_fail(2)) SWIG_fail;
32209 {
32210 PyThreadState* __tstate = wxPyBeginAllowThreads();
32211 result = (wxMenuItem *)(arg1)->Append(arg2);
32212
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 {
32217 resultobj = wxPyMake_wxObject(result, 0);
32218 }
32219 return resultobj;
32220 fail:
32221 return NULL;
32222 }
32223
32224
32225 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32226 PyObject *resultobj;
32227 wxMenu *arg1 = (wxMenu *) 0 ;
32228 PyObject * obj0 = 0 ;
32229 char *kwnames[] = {
32230 (char *) "self", NULL
32231 };
32232
32233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32235 if (SWIG_arg_fail(1)) SWIG_fail;
32236 {
32237 PyThreadState* __tstate = wxPyBeginAllowThreads();
32238 (arg1)->Break();
32239
32240 wxPyEndAllowThreads(__tstate);
32241 if (PyErr_Occurred()) SWIG_fail;
32242 }
32243 Py_INCREF(Py_None); resultobj = Py_None;
32244 return resultobj;
32245 fail:
32246 return NULL;
32247 }
32248
32249
32250 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32251 PyObject *resultobj;
32252 wxMenu *arg1 = (wxMenu *) 0 ;
32253 size_t arg2 ;
32254 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32255 wxMenuItem *result;
32256 PyObject * obj0 = 0 ;
32257 PyObject * obj1 = 0 ;
32258 PyObject * obj2 = 0 ;
32259 char *kwnames[] = {
32260 (char *) "self",(char *) "pos",(char *) "item", NULL
32261 };
32262
32263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32265 if (SWIG_arg_fail(1)) SWIG_fail;
32266 {
32267 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32268 if (SWIG_arg_fail(2)) SWIG_fail;
32269 }
32270 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32271 if (SWIG_arg_fail(3)) SWIG_fail;
32272 {
32273 PyThreadState* __tstate = wxPyBeginAllowThreads();
32274 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32275
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 {
32280 resultobj = wxPyMake_wxObject(result, 0);
32281 }
32282 return resultobj;
32283 fail:
32284 return NULL;
32285 }
32286
32287
32288 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32289 PyObject *resultobj;
32290 wxMenu *arg1 = (wxMenu *) 0 ;
32291 size_t arg2 ;
32292 int arg3 ;
32293 wxString *arg4 = 0 ;
32294 wxString const &arg5_defvalue = wxPyEmptyString ;
32295 wxString *arg5 = (wxString *) &arg5_defvalue ;
32296 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32297 wxMenuItem *result;
32298 bool temp4 = false ;
32299 bool temp5 = false ;
32300 PyObject * obj0 = 0 ;
32301 PyObject * obj1 = 0 ;
32302 PyObject * obj2 = 0 ;
32303 PyObject * obj3 = 0 ;
32304 PyObject * obj4 = 0 ;
32305 PyObject * obj5 = 0 ;
32306 char *kwnames[] = {
32307 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32308 };
32309
32310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32312 if (SWIG_arg_fail(1)) SWIG_fail;
32313 {
32314 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32315 if (SWIG_arg_fail(2)) SWIG_fail;
32316 }
32317 {
32318 arg3 = (int)(SWIG_As_int(obj2));
32319 if (SWIG_arg_fail(3)) SWIG_fail;
32320 }
32321 {
32322 arg4 = wxString_in_helper(obj3);
32323 if (arg4 == NULL) SWIG_fail;
32324 temp4 = true;
32325 }
32326 if (obj4) {
32327 {
32328 arg5 = wxString_in_helper(obj4);
32329 if (arg5 == NULL) SWIG_fail;
32330 temp5 = true;
32331 }
32332 }
32333 if (obj5) {
32334 {
32335 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32336 if (SWIG_arg_fail(6)) SWIG_fail;
32337 }
32338 }
32339 {
32340 PyThreadState* __tstate = wxPyBeginAllowThreads();
32341 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32342
32343 wxPyEndAllowThreads(__tstate);
32344 if (PyErr_Occurred()) SWIG_fail;
32345 }
32346 {
32347 resultobj = wxPyMake_wxObject(result, 0);
32348 }
32349 {
32350 if (temp4)
32351 delete arg4;
32352 }
32353 {
32354 if (temp5)
32355 delete arg5;
32356 }
32357 return resultobj;
32358 fail:
32359 {
32360 if (temp4)
32361 delete arg4;
32362 }
32363 {
32364 if (temp5)
32365 delete arg5;
32366 }
32367 return NULL;
32368 }
32369
32370
32371 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32372 PyObject *resultobj;
32373 wxMenu *arg1 = (wxMenu *) 0 ;
32374 size_t arg2 ;
32375 wxMenuItem *result;
32376 PyObject * obj0 = 0 ;
32377 PyObject * obj1 = 0 ;
32378 char *kwnames[] = {
32379 (char *) "self",(char *) "pos", NULL
32380 };
32381
32382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32384 if (SWIG_arg_fail(1)) SWIG_fail;
32385 {
32386 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32387 if (SWIG_arg_fail(2)) SWIG_fail;
32388 }
32389 {
32390 PyThreadState* __tstate = wxPyBeginAllowThreads();
32391 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32392
32393 wxPyEndAllowThreads(__tstate);
32394 if (PyErr_Occurred()) SWIG_fail;
32395 }
32396 {
32397 resultobj = wxPyMake_wxObject(result, 0);
32398 }
32399 return resultobj;
32400 fail:
32401 return NULL;
32402 }
32403
32404
32405 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32406 PyObject *resultobj;
32407 wxMenu *arg1 = (wxMenu *) 0 ;
32408 size_t arg2 ;
32409 int arg3 ;
32410 wxString *arg4 = 0 ;
32411 wxString const &arg5_defvalue = wxPyEmptyString ;
32412 wxString *arg5 = (wxString *) &arg5_defvalue ;
32413 wxMenuItem *result;
32414 bool temp4 = false ;
32415 bool temp5 = false ;
32416 PyObject * obj0 = 0 ;
32417 PyObject * obj1 = 0 ;
32418 PyObject * obj2 = 0 ;
32419 PyObject * obj3 = 0 ;
32420 PyObject * obj4 = 0 ;
32421 char *kwnames[] = {
32422 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32423 };
32424
32425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32427 if (SWIG_arg_fail(1)) SWIG_fail;
32428 {
32429 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32430 if (SWIG_arg_fail(2)) SWIG_fail;
32431 }
32432 {
32433 arg3 = (int)(SWIG_As_int(obj2));
32434 if (SWIG_arg_fail(3)) SWIG_fail;
32435 }
32436 {
32437 arg4 = wxString_in_helper(obj3);
32438 if (arg4 == NULL) SWIG_fail;
32439 temp4 = true;
32440 }
32441 if (obj4) {
32442 {
32443 arg5 = wxString_in_helper(obj4);
32444 if (arg5 == NULL) SWIG_fail;
32445 temp5 = true;
32446 }
32447 }
32448 {
32449 PyThreadState* __tstate = wxPyBeginAllowThreads();
32450 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32451
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 {
32456 resultobj = wxPyMake_wxObject(result, 0);
32457 }
32458 {
32459 if (temp4)
32460 delete arg4;
32461 }
32462 {
32463 if (temp5)
32464 delete arg5;
32465 }
32466 return resultobj;
32467 fail:
32468 {
32469 if (temp4)
32470 delete arg4;
32471 }
32472 {
32473 if (temp5)
32474 delete arg5;
32475 }
32476 return NULL;
32477 }
32478
32479
32480 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32481 PyObject *resultobj;
32482 wxMenu *arg1 = (wxMenu *) 0 ;
32483 size_t arg2 ;
32484 int arg3 ;
32485 wxString *arg4 = 0 ;
32486 wxString const &arg5_defvalue = wxPyEmptyString ;
32487 wxString *arg5 = (wxString *) &arg5_defvalue ;
32488 wxMenuItem *result;
32489 bool temp4 = false ;
32490 bool temp5 = false ;
32491 PyObject * obj0 = 0 ;
32492 PyObject * obj1 = 0 ;
32493 PyObject * obj2 = 0 ;
32494 PyObject * obj3 = 0 ;
32495 PyObject * obj4 = 0 ;
32496 char *kwnames[] = {
32497 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32498 };
32499
32500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32502 if (SWIG_arg_fail(1)) SWIG_fail;
32503 {
32504 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32505 if (SWIG_arg_fail(2)) SWIG_fail;
32506 }
32507 {
32508 arg3 = (int)(SWIG_As_int(obj2));
32509 if (SWIG_arg_fail(3)) SWIG_fail;
32510 }
32511 {
32512 arg4 = wxString_in_helper(obj3);
32513 if (arg4 == NULL) SWIG_fail;
32514 temp4 = true;
32515 }
32516 if (obj4) {
32517 {
32518 arg5 = wxString_in_helper(obj4);
32519 if (arg5 == NULL) SWIG_fail;
32520 temp5 = true;
32521 }
32522 }
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32526
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 {
32531 resultobj = wxPyMake_wxObject(result, 0);
32532 }
32533 {
32534 if (temp4)
32535 delete arg4;
32536 }
32537 {
32538 if (temp5)
32539 delete arg5;
32540 }
32541 return resultobj;
32542 fail:
32543 {
32544 if (temp4)
32545 delete arg4;
32546 }
32547 {
32548 if (temp5)
32549 delete arg5;
32550 }
32551 return NULL;
32552 }
32553
32554
32555 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32556 PyObject *resultobj;
32557 wxMenu *arg1 = (wxMenu *) 0 ;
32558 size_t arg2 ;
32559 int arg3 ;
32560 wxString *arg4 = 0 ;
32561 wxMenu *arg5 = (wxMenu *) 0 ;
32562 wxString const &arg6_defvalue = wxPyEmptyString ;
32563 wxString *arg6 = (wxString *) &arg6_defvalue ;
32564 wxMenuItem *result;
32565 bool temp4 = false ;
32566 bool temp6 = false ;
32567 PyObject * obj0 = 0 ;
32568 PyObject * obj1 = 0 ;
32569 PyObject * obj2 = 0 ;
32570 PyObject * obj3 = 0 ;
32571 PyObject * obj4 = 0 ;
32572 PyObject * obj5 = 0 ;
32573 char *kwnames[] = {
32574 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32575 };
32576
32577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32579 if (SWIG_arg_fail(1)) SWIG_fail;
32580 {
32581 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32582 if (SWIG_arg_fail(2)) SWIG_fail;
32583 }
32584 {
32585 arg3 = (int)(SWIG_As_int(obj2));
32586 if (SWIG_arg_fail(3)) SWIG_fail;
32587 }
32588 {
32589 arg4 = wxString_in_helper(obj3);
32590 if (arg4 == NULL) SWIG_fail;
32591 temp4 = true;
32592 }
32593 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32594 if (SWIG_arg_fail(5)) SWIG_fail;
32595 if (obj5) {
32596 {
32597 arg6 = wxString_in_helper(obj5);
32598 if (arg6 == NULL) SWIG_fail;
32599 temp6 = true;
32600 }
32601 }
32602 {
32603 PyThreadState* __tstate = wxPyBeginAllowThreads();
32604 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32605
32606 wxPyEndAllowThreads(__tstate);
32607 if (PyErr_Occurred()) SWIG_fail;
32608 }
32609 {
32610 resultobj = wxPyMake_wxObject(result, 0);
32611 }
32612 {
32613 if (temp4)
32614 delete arg4;
32615 }
32616 {
32617 if (temp6)
32618 delete arg6;
32619 }
32620 return resultobj;
32621 fail:
32622 {
32623 if (temp4)
32624 delete arg4;
32625 }
32626 {
32627 if (temp6)
32628 delete arg6;
32629 }
32630 return NULL;
32631 }
32632
32633
32634 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32635 PyObject *resultobj;
32636 wxMenu *arg1 = (wxMenu *) 0 ;
32637 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32638 wxMenuItem *result;
32639 PyObject * obj0 = 0 ;
32640 PyObject * obj1 = 0 ;
32641 char *kwnames[] = {
32642 (char *) "self",(char *) "item", NULL
32643 };
32644
32645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32647 if (SWIG_arg_fail(1)) SWIG_fail;
32648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32649 if (SWIG_arg_fail(2)) SWIG_fail;
32650 {
32651 PyThreadState* __tstate = wxPyBeginAllowThreads();
32652 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32653
32654 wxPyEndAllowThreads(__tstate);
32655 if (PyErr_Occurred()) SWIG_fail;
32656 }
32657 {
32658 resultobj = wxPyMake_wxObject(result, 0);
32659 }
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32667 PyObject *resultobj;
32668 wxMenu *arg1 = (wxMenu *) 0 ;
32669 int arg2 ;
32670 wxString *arg3 = 0 ;
32671 wxString const &arg4_defvalue = wxPyEmptyString ;
32672 wxString *arg4 = (wxString *) &arg4_defvalue ;
32673 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32674 wxMenuItem *result;
32675 bool temp3 = false ;
32676 bool temp4 = false ;
32677 PyObject * obj0 = 0 ;
32678 PyObject * obj1 = 0 ;
32679 PyObject * obj2 = 0 ;
32680 PyObject * obj3 = 0 ;
32681 PyObject * obj4 = 0 ;
32682 char *kwnames[] = {
32683 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32684 };
32685
32686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32688 if (SWIG_arg_fail(1)) SWIG_fail;
32689 {
32690 arg2 = (int)(SWIG_As_int(obj1));
32691 if (SWIG_arg_fail(2)) SWIG_fail;
32692 }
32693 {
32694 arg3 = wxString_in_helper(obj2);
32695 if (arg3 == NULL) SWIG_fail;
32696 temp3 = true;
32697 }
32698 if (obj3) {
32699 {
32700 arg4 = wxString_in_helper(obj3);
32701 if (arg4 == NULL) SWIG_fail;
32702 temp4 = true;
32703 }
32704 }
32705 if (obj4) {
32706 {
32707 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32708 if (SWIG_arg_fail(5)) SWIG_fail;
32709 }
32710 }
32711 {
32712 PyThreadState* __tstate = wxPyBeginAllowThreads();
32713 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32714
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 {
32719 resultobj = wxPyMake_wxObject(result, 0);
32720 }
32721 {
32722 if (temp3)
32723 delete arg3;
32724 }
32725 {
32726 if (temp4)
32727 delete arg4;
32728 }
32729 return resultobj;
32730 fail:
32731 {
32732 if (temp3)
32733 delete arg3;
32734 }
32735 {
32736 if (temp4)
32737 delete arg4;
32738 }
32739 return NULL;
32740 }
32741
32742
32743 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32744 PyObject *resultobj;
32745 wxMenu *arg1 = (wxMenu *) 0 ;
32746 wxMenuItem *result;
32747 PyObject * obj0 = 0 ;
32748 char *kwnames[] = {
32749 (char *) "self", NULL
32750 };
32751
32752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32754 if (SWIG_arg_fail(1)) SWIG_fail;
32755 {
32756 PyThreadState* __tstate = wxPyBeginAllowThreads();
32757 result = (wxMenuItem *)(arg1)->PrependSeparator();
32758
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 {
32763 resultobj = wxPyMake_wxObject(result, 0);
32764 }
32765 return resultobj;
32766 fail:
32767 return NULL;
32768 }
32769
32770
32771 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32772 PyObject *resultobj;
32773 wxMenu *arg1 = (wxMenu *) 0 ;
32774 int arg2 ;
32775 wxString *arg3 = 0 ;
32776 wxString const &arg4_defvalue = wxPyEmptyString ;
32777 wxString *arg4 = (wxString *) &arg4_defvalue ;
32778 wxMenuItem *result;
32779 bool temp3 = false ;
32780 bool temp4 = false ;
32781 PyObject * obj0 = 0 ;
32782 PyObject * obj1 = 0 ;
32783 PyObject * obj2 = 0 ;
32784 PyObject * obj3 = 0 ;
32785 char *kwnames[] = {
32786 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32787 };
32788
32789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32791 if (SWIG_arg_fail(1)) SWIG_fail;
32792 {
32793 arg2 = (int)(SWIG_As_int(obj1));
32794 if (SWIG_arg_fail(2)) SWIG_fail;
32795 }
32796 {
32797 arg3 = wxString_in_helper(obj2);
32798 if (arg3 == NULL) SWIG_fail;
32799 temp3 = true;
32800 }
32801 if (obj3) {
32802 {
32803 arg4 = wxString_in_helper(obj3);
32804 if (arg4 == NULL) SWIG_fail;
32805 temp4 = true;
32806 }
32807 }
32808 {
32809 PyThreadState* __tstate = wxPyBeginAllowThreads();
32810 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32811
32812 wxPyEndAllowThreads(__tstate);
32813 if (PyErr_Occurred()) SWIG_fail;
32814 }
32815 {
32816 resultobj = wxPyMake_wxObject(result, 0);
32817 }
32818 {
32819 if (temp3)
32820 delete arg3;
32821 }
32822 {
32823 if (temp4)
32824 delete arg4;
32825 }
32826 return resultobj;
32827 fail:
32828 {
32829 if (temp3)
32830 delete arg3;
32831 }
32832 {
32833 if (temp4)
32834 delete arg4;
32835 }
32836 return NULL;
32837 }
32838
32839
32840 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32841 PyObject *resultobj;
32842 wxMenu *arg1 = (wxMenu *) 0 ;
32843 int arg2 ;
32844 wxString *arg3 = 0 ;
32845 wxString const &arg4_defvalue = wxPyEmptyString ;
32846 wxString *arg4 = (wxString *) &arg4_defvalue ;
32847 wxMenuItem *result;
32848 bool temp3 = false ;
32849 bool temp4 = false ;
32850 PyObject * obj0 = 0 ;
32851 PyObject * obj1 = 0 ;
32852 PyObject * obj2 = 0 ;
32853 PyObject * obj3 = 0 ;
32854 char *kwnames[] = {
32855 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32856 };
32857
32858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32860 if (SWIG_arg_fail(1)) SWIG_fail;
32861 {
32862 arg2 = (int)(SWIG_As_int(obj1));
32863 if (SWIG_arg_fail(2)) SWIG_fail;
32864 }
32865 {
32866 arg3 = wxString_in_helper(obj2);
32867 if (arg3 == NULL) SWIG_fail;
32868 temp3 = true;
32869 }
32870 if (obj3) {
32871 {
32872 arg4 = wxString_in_helper(obj3);
32873 if (arg4 == NULL) SWIG_fail;
32874 temp4 = true;
32875 }
32876 }
32877 {
32878 PyThreadState* __tstate = wxPyBeginAllowThreads();
32879 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32880
32881 wxPyEndAllowThreads(__tstate);
32882 if (PyErr_Occurred()) SWIG_fail;
32883 }
32884 {
32885 resultobj = wxPyMake_wxObject(result, 0);
32886 }
32887 {
32888 if (temp3)
32889 delete arg3;
32890 }
32891 {
32892 if (temp4)
32893 delete arg4;
32894 }
32895 return resultobj;
32896 fail:
32897 {
32898 if (temp3)
32899 delete arg3;
32900 }
32901 {
32902 if (temp4)
32903 delete arg4;
32904 }
32905 return NULL;
32906 }
32907
32908
32909 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj;
32911 wxMenu *arg1 = (wxMenu *) 0 ;
32912 int arg2 ;
32913 wxString *arg3 = 0 ;
32914 wxMenu *arg4 = (wxMenu *) 0 ;
32915 wxString const &arg5_defvalue = wxPyEmptyString ;
32916 wxString *arg5 = (wxString *) &arg5_defvalue ;
32917 wxMenuItem *result;
32918 bool temp3 = false ;
32919 bool temp5 = false ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 PyObject * obj2 = 0 ;
32923 PyObject * obj3 = 0 ;
32924 PyObject * obj4 = 0 ;
32925 char *kwnames[] = {
32926 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32927 };
32928
32929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32931 if (SWIG_arg_fail(1)) SWIG_fail;
32932 {
32933 arg2 = (int)(SWIG_As_int(obj1));
32934 if (SWIG_arg_fail(2)) SWIG_fail;
32935 }
32936 {
32937 arg3 = wxString_in_helper(obj2);
32938 if (arg3 == NULL) SWIG_fail;
32939 temp3 = true;
32940 }
32941 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32942 if (SWIG_arg_fail(4)) SWIG_fail;
32943 if (obj4) {
32944 {
32945 arg5 = wxString_in_helper(obj4);
32946 if (arg5 == NULL) SWIG_fail;
32947 temp5 = true;
32948 }
32949 }
32950 {
32951 PyThreadState* __tstate = wxPyBeginAllowThreads();
32952 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32953
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 {
32958 resultobj = wxPyMake_wxObject(result, 0);
32959 }
32960 {
32961 if (temp3)
32962 delete arg3;
32963 }
32964 {
32965 if (temp5)
32966 delete arg5;
32967 }
32968 return resultobj;
32969 fail:
32970 {
32971 if (temp3)
32972 delete arg3;
32973 }
32974 {
32975 if (temp5)
32976 delete arg5;
32977 }
32978 return NULL;
32979 }
32980
32981
32982 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32983 PyObject *resultobj;
32984 wxMenu *arg1 = (wxMenu *) 0 ;
32985 int arg2 ;
32986 wxMenuItem *result;
32987 PyObject * obj0 = 0 ;
32988 PyObject * obj1 = 0 ;
32989 char *kwnames[] = {
32990 (char *) "self",(char *) "id", NULL
32991 };
32992
32993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32995 if (SWIG_arg_fail(1)) SWIG_fail;
32996 {
32997 arg2 = (int)(SWIG_As_int(obj1));
32998 if (SWIG_arg_fail(2)) SWIG_fail;
32999 }
33000 {
33001 PyThreadState* __tstate = wxPyBeginAllowThreads();
33002 result = (wxMenuItem *)(arg1)->Remove(arg2);
33003
33004 wxPyEndAllowThreads(__tstate);
33005 if (PyErr_Occurred()) SWIG_fail;
33006 }
33007 {
33008 resultobj = wxPyMake_wxObject(result, 0);
33009 }
33010 return resultobj;
33011 fail:
33012 return NULL;
33013 }
33014
33015
33016 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33017 PyObject *resultobj;
33018 wxMenu *arg1 = (wxMenu *) 0 ;
33019 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33020 wxMenuItem *result;
33021 PyObject * obj0 = 0 ;
33022 PyObject * obj1 = 0 ;
33023 char *kwnames[] = {
33024 (char *) "self",(char *) "item", NULL
33025 };
33026
33027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33029 if (SWIG_arg_fail(1)) SWIG_fail;
33030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33031 if (SWIG_arg_fail(2)) SWIG_fail;
33032 {
33033 PyThreadState* __tstate = wxPyBeginAllowThreads();
33034 result = (wxMenuItem *)(arg1)->Remove(arg2);
33035
33036 wxPyEndAllowThreads(__tstate);
33037 if (PyErr_Occurred()) SWIG_fail;
33038 }
33039 {
33040 resultobj = wxPyMake_wxObject(result, 0);
33041 }
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33049 PyObject *resultobj;
33050 wxMenu *arg1 = (wxMenu *) 0 ;
33051 int arg2 ;
33052 bool result;
33053 PyObject * obj0 = 0 ;
33054 PyObject * obj1 = 0 ;
33055 char *kwnames[] = {
33056 (char *) "self",(char *) "id", NULL
33057 };
33058
33059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33061 if (SWIG_arg_fail(1)) SWIG_fail;
33062 {
33063 arg2 = (int)(SWIG_As_int(obj1));
33064 if (SWIG_arg_fail(2)) SWIG_fail;
33065 }
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 result = (bool)(arg1)->Delete(arg2);
33069
33070 wxPyEndAllowThreads(__tstate);
33071 if (PyErr_Occurred()) SWIG_fail;
33072 }
33073 {
33074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33075 }
33076 return resultobj;
33077 fail:
33078 return NULL;
33079 }
33080
33081
33082 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33083 PyObject *resultobj;
33084 wxMenu *arg1 = (wxMenu *) 0 ;
33085 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33086 bool result;
33087 PyObject * obj0 = 0 ;
33088 PyObject * obj1 = 0 ;
33089 char *kwnames[] = {
33090 (char *) "self",(char *) "item", NULL
33091 };
33092
33093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33095 if (SWIG_arg_fail(1)) SWIG_fail;
33096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33097 if (SWIG_arg_fail(2)) SWIG_fail;
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (bool)(arg1)->Delete(arg2);
33101
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 {
33106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33107 }
33108 return resultobj;
33109 fail:
33110 return NULL;
33111 }
33112
33113
33114 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj;
33116 wxMenu *arg1 = (wxMenu *) 0 ;
33117 PyObject * obj0 = 0 ;
33118 char *kwnames[] = {
33119 (char *) "self", NULL
33120 };
33121
33122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33124 if (SWIG_arg_fail(1)) SWIG_fail;
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 wxMenu_Destroy(arg1);
33128
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 Py_INCREF(Py_None); resultobj = Py_None;
33133 return resultobj;
33134 fail:
33135 return NULL;
33136 }
33137
33138
33139 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33140 PyObject *resultobj;
33141 wxMenu *arg1 = (wxMenu *) 0 ;
33142 int arg2 ;
33143 bool result;
33144 PyObject * obj0 = 0 ;
33145 PyObject * obj1 = 0 ;
33146 char *kwnames[] = {
33147 (char *) "self",(char *) "id", NULL
33148 };
33149
33150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33152 if (SWIG_arg_fail(1)) SWIG_fail;
33153 {
33154 arg2 = (int)(SWIG_As_int(obj1));
33155 if (SWIG_arg_fail(2)) SWIG_fail;
33156 }
33157 {
33158 PyThreadState* __tstate = wxPyBeginAllowThreads();
33159 result = (bool)(arg1)->Destroy(arg2);
33160
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 {
33165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33166 }
33167 return resultobj;
33168 fail:
33169 return NULL;
33170 }
33171
33172
33173 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33174 PyObject *resultobj;
33175 wxMenu *arg1 = (wxMenu *) 0 ;
33176 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33177 bool result;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 char *kwnames[] = {
33181 (char *) "self",(char *) "item", NULL
33182 };
33183
33184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33186 if (SWIG_arg_fail(1)) SWIG_fail;
33187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33188 if (SWIG_arg_fail(2)) SWIG_fail;
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 result = (bool)(arg1)->Destroy(arg2);
33192
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 {
33197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33198 }
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj;
33207 wxMenu *arg1 = (wxMenu *) 0 ;
33208 size_t result;
33209 PyObject * obj0 = 0 ;
33210 char *kwnames[] = {
33211 (char *) "self", NULL
33212 };
33213
33214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33216 if (SWIG_arg_fail(1)) SWIG_fail;
33217 {
33218 PyThreadState* __tstate = wxPyBeginAllowThreads();
33219 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33220
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 {
33225 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33226 }
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33234 PyObject *resultobj;
33235 wxMenu *arg1 = (wxMenu *) 0 ;
33236 PyObject *result;
33237 PyObject * obj0 = 0 ;
33238 char *kwnames[] = {
33239 (char *) "self", NULL
33240 };
33241
33242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33244 if (SWIG_arg_fail(1)) SWIG_fail;
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33248
33249 wxPyEndAllowThreads(__tstate);
33250 if (PyErr_Occurred()) SWIG_fail;
33251 }
33252 resultobj = result;
33253 return resultobj;
33254 fail:
33255 return NULL;
33256 }
33257
33258
33259 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33260 PyObject *resultobj;
33261 wxMenu *arg1 = (wxMenu *) 0 ;
33262 wxString *arg2 = 0 ;
33263 int result;
33264 bool temp2 = false ;
33265 PyObject * obj0 = 0 ;
33266 PyObject * obj1 = 0 ;
33267 char *kwnames[] = {
33268 (char *) "self",(char *) "item", NULL
33269 };
33270
33271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33273 if (SWIG_arg_fail(1)) SWIG_fail;
33274 {
33275 arg2 = wxString_in_helper(obj1);
33276 if (arg2 == NULL) SWIG_fail;
33277 temp2 = true;
33278 }
33279 {
33280 PyThreadState* __tstate = wxPyBeginAllowThreads();
33281 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33282
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 {
33287 resultobj = SWIG_From_int((int)(result));
33288 }
33289 {
33290 if (temp2)
33291 delete arg2;
33292 }
33293 return resultobj;
33294 fail:
33295 {
33296 if (temp2)
33297 delete arg2;
33298 }
33299 return NULL;
33300 }
33301
33302
33303 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj;
33305 wxMenu *arg1 = (wxMenu *) 0 ;
33306 int arg2 ;
33307 wxMenuItem *result;
33308 PyObject * obj0 = 0 ;
33309 PyObject * obj1 = 0 ;
33310 char *kwnames[] = {
33311 (char *) "self",(char *) "id", NULL
33312 };
33313
33314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33316 if (SWIG_arg_fail(1)) SWIG_fail;
33317 {
33318 arg2 = (int)(SWIG_As_int(obj1));
33319 if (SWIG_arg_fail(2)) SWIG_fail;
33320 }
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33324
33325 wxPyEndAllowThreads(__tstate);
33326 if (PyErr_Occurred()) SWIG_fail;
33327 }
33328 {
33329 resultobj = wxPyMake_wxObject(result, 0);
33330 }
33331 return resultobj;
33332 fail:
33333 return NULL;
33334 }
33335
33336
33337 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33338 PyObject *resultobj;
33339 wxMenu *arg1 = (wxMenu *) 0 ;
33340 size_t arg2 ;
33341 wxMenuItem *result;
33342 PyObject * obj0 = 0 ;
33343 PyObject * obj1 = 0 ;
33344 char *kwnames[] = {
33345 (char *) "self",(char *) "position", NULL
33346 };
33347
33348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33350 if (SWIG_arg_fail(1)) SWIG_fail;
33351 {
33352 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33353 if (SWIG_arg_fail(2)) SWIG_fail;
33354 }
33355 {
33356 PyThreadState* __tstate = wxPyBeginAllowThreads();
33357 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33358
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 {
33363 resultobj = wxPyMake_wxObject(result, 0);
33364 }
33365 return resultobj;
33366 fail:
33367 return NULL;
33368 }
33369
33370
33371 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33372 PyObject *resultobj;
33373 wxMenu *arg1 = (wxMenu *) 0 ;
33374 int arg2 ;
33375 bool arg3 ;
33376 PyObject * obj0 = 0 ;
33377 PyObject * obj1 = 0 ;
33378 PyObject * obj2 = 0 ;
33379 char *kwnames[] = {
33380 (char *) "self",(char *) "id",(char *) "enable", NULL
33381 };
33382
33383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33385 if (SWIG_arg_fail(1)) SWIG_fail;
33386 {
33387 arg2 = (int)(SWIG_As_int(obj1));
33388 if (SWIG_arg_fail(2)) SWIG_fail;
33389 }
33390 {
33391 arg3 = (bool)(SWIG_As_bool(obj2));
33392 if (SWIG_arg_fail(3)) SWIG_fail;
33393 }
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 (arg1)->Enable(arg2,arg3);
33397
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 Py_INCREF(Py_None); resultobj = Py_None;
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33409 PyObject *resultobj;
33410 wxMenu *arg1 = (wxMenu *) 0 ;
33411 int arg2 ;
33412 bool result;
33413 PyObject * obj0 = 0 ;
33414 PyObject * obj1 = 0 ;
33415 char *kwnames[] = {
33416 (char *) "self",(char *) "id", NULL
33417 };
33418
33419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33421 if (SWIG_arg_fail(1)) SWIG_fail;
33422 {
33423 arg2 = (int)(SWIG_As_int(obj1));
33424 if (SWIG_arg_fail(2)) SWIG_fail;
33425 }
33426 {
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33429
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 {
33434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33435 }
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33443 PyObject *resultobj;
33444 wxMenu *arg1 = (wxMenu *) 0 ;
33445 int arg2 ;
33446 bool arg3 ;
33447 PyObject * obj0 = 0 ;
33448 PyObject * obj1 = 0 ;
33449 PyObject * obj2 = 0 ;
33450 char *kwnames[] = {
33451 (char *) "self",(char *) "id",(char *) "check", NULL
33452 };
33453
33454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33456 if (SWIG_arg_fail(1)) SWIG_fail;
33457 {
33458 arg2 = (int)(SWIG_As_int(obj1));
33459 if (SWIG_arg_fail(2)) SWIG_fail;
33460 }
33461 {
33462 arg3 = (bool)(SWIG_As_bool(obj2));
33463 if (SWIG_arg_fail(3)) SWIG_fail;
33464 }
33465 {
33466 PyThreadState* __tstate = wxPyBeginAllowThreads();
33467 (arg1)->Check(arg2,arg3);
33468
33469 wxPyEndAllowThreads(__tstate);
33470 if (PyErr_Occurred()) SWIG_fail;
33471 }
33472 Py_INCREF(Py_None); resultobj = Py_None;
33473 return resultobj;
33474 fail:
33475 return NULL;
33476 }
33477
33478
33479 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj;
33481 wxMenu *arg1 = (wxMenu *) 0 ;
33482 int arg2 ;
33483 bool result;
33484 PyObject * obj0 = 0 ;
33485 PyObject * obj1 = 0 ;
33486 char *kwnames[] = {
33487 (char *) "self",(char *) "id", NULL
33488 };
33489
33490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33492 if (SWIG_arg_fail(1)) SWIG_fail;
33493 {
33494 arg2 = (int)(SWIG_As_int(obj1));
33495 if (SWIG_arg_fail(2)) SWIG_fail;
33496 }
33497 {
33498 PyThreadState* __tstate = wxPyBeginAllowThreads();
33499 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33500
33501 wxPyEndAllowThreads(__tstate);
33502 if (PyErr_Occurred()) SWIG_fail;
33503 }
33504 {
33505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33506 }
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj;
33515 wxMenu *arg1 = (wxMenu *) 0 ;
33516 int arg2 ;
33517 wxString *arg3 = 0 ;
33518 bool temp3 = false ;
33519 PyObject * obj0 = 0 ;
33520 PyObject * obj1 = 0 ;
33521 PyObject * obj2 = 0 ;
33522 char *kwnames[] = {
33523 (char *) "self",(char *) "id",(char *) "label", NULL
33524 };
33525
33526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33528 if (SWIG_arg_fail(1)) SWIG_fail;
33529 {
33530 arg2 = (int)(SWIG_As_int(obj1));
33531 if (SWIG_arg_fail(2)) SWIG_fail;
33532 }
33533 {
33534 arg3 = wxString_in_helper(obj2);
33535 if (arg3 == NULL) SWIG_fail;
33536 temp3 = true;
33537 }
33538 {
33539 PyThreadState* __tstate = wxPyBeginAllowThreads();
33540 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33541
33542 wxPyEndAllowThreads(__tstate);
33543 if (PyErr_Occurred()) SWIG_fail;
33544 }
33545 Py_INCREF(Py_None); resultobj = Py_None;
33546 {
33547 if (temp3)
33548 delete arg3;
33549 }
33550 return resultobj;
33551 fail:
33552 {
33553 if (temp3)
33554 delete arg3;
33555 }
33556 return NULL;
33557 }
33558
33559
33560 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33561 PyObject *resultobj;
33562 wxMenu *arg1 = (wxMenu *) 0 ;
33563 int arg2 ;
33564 wxString result;
33565 PyObject * obj0 = 0 ;
33566 PyObject * obj1 = 0 ;
33567 char *kwnames[] = {
33568 (char *) "self",(char *) "id", NULL
33569 };
33570
33571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33573 if (SWIG_arg_fail(1)) SWIG_fail;
33574 {
33575 arg2 = (int)(SWIG_As_int(obj1));
33576 if (SWIG_arg_fail(2)) SWIG_fail;
33577 }
33578 {
33579 PyThreadState* __tstate = wxPyBeginAllowThreads();
33580 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33581
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 {
33586 #if wxUSE_UNICODE
33587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33588 #else
33589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33590 #endif
33591 }
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33599 PyObject *resultobj;
33600 wxMenu *arg1 = (wxMenu *) 0 ;
33601 int arg2 ;
33602 wxString *arg3 = 0 ;
33603 bool temp3 = false ;
33604 PyObject * obj0 = 0 ;
33605 PyObject * obj1 = 0 ;
33606 PyObject * obj2 = 0 ;
33607 char *kwnames[] = {
33608 (char *) "self",(char *) "id",(char *) "helpString", NULL
33609 };
33610
33611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33613 if (SWIG_arg_fail(1)) SWIG_fail;
33614 {
33615 arg2 = (int)(SWIG_As_int(obj1));
33616 if (SWIG_arg_fail(2)) SWIG_fail;
33617 }
33618 {
33619 arg3 = wxString_in_helper(obj2);
33620 if (arg3 == NULL) SWIG_fail;
33621 temp3 = true;
33622 }
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33626
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 Py_INCREF(Py_None); resultobj = Py_None;
33631 {
33632 if (temp3)
33633 delete arg3;
33634 }
33635 return resultobj;
33636 fail:
33637 {
33638 if (temp3)
33639 delete arg3;
33640 }
33641 return NULL;
33642 }
33643
33644
33645 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33646 PyObject *resultobj;
33647 wxMenu *arg1 = (wxMenu *) 0 ;
33648 int arg2 ;
33649 wxString result;
33650 PyObject * obj0 = 0 ;
33651 PyObject * obj1 = 0 ;
33652 char *kwnames[] = {
33653 (char *) "self",(char *) "id", NULL
33654 };
33655
33656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33658 if (SWIG_arg_fail(1)) SWIG_fail;
33659 {
33660 arg2 = (int)(SWIG_As_int(obj1));
33661 if (SWIG_arg_fail(2)) SWIG_fail;
33662 }
33663 {
33664 PyThreadState* __tstate = wxPyBeginAllowThreads();
33665 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33666
33667 wxPyEndAllowThreads(__tstate);
33668 if (PyErr_Occurred()) SWIG_fail;
33669 }
33670 {
33671 #if wxUSE_UNICODE
33672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33673 #else
33674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33675 #endif
33676 }
33677 return resultobj;
33678 fail:
33679 return NULL;
33680 }
33681
33682
33683 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33684 PyObject *resultobj;
33685 wxMenu *arg1 = (wxMenu *) 0 ;
33686 wxString *arg2 = 0 ;
33687 bool temp2 = false ;
33688 PyObject * obj0 = 0 ;
33689 PyObject * obj1 = 0 ;
33690 char *kwnames[] = {
33691 (char *) "self",(char *) "title", NULL
33692 };
33693
33694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33696 if (SWIG_arg_fail(1)) SWIG_fail;
33697 {
33698 arg2 = wxString_in_helper(obj1);
33699 if (arg2 == NULL) SWIG_fail;
33700 temp2 = true;
33701 }
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 (arg1)->SetTitle((wxString const &)*arg2);
33705
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 Py_INCREF(Py_None); resultobj = Py_None;
33710 {
33711 if (temp2)
33712 delete arg2;
33713 }
33714 return resultobj;
33715 fail:
33716 {
33717 if (temp2)
33718 delete arg2;
33719 }
33720 return NULL;
33721 }
33722
33723
33724 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj;
33726 wxMenu *arg1 = (wxMenu *) 0 ;
33727 wxString result;
33728 PyObject * obj0 = 0 ;
33729 char *kwnames[] = {
33730 (char *) "self", NULL
33731 };
33732
33733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33735 if (SWIG_arg_fail(1)) SWIG_fail;
33736 {
33737 PyThreadState* __tstate = wxPyBeginAllowThreads();
33738 result = ((wxMenu const *)arg1)->GetTitle();
33739
33740 wxPyEndAllowThreads(__tstate);
33741 if (PyErr_Occurred()) SWIG_fail;
33742 }
33743 {
33744 #if wxUSE_UNICODE
33745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33746 #else
33747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33748 #endif
33749 }
33750 return resultobj;
33751 fail:
33752 return NULL;
33753 }
33754
33755
33756 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33757 PyObject *resultobj;
33758 wxMenu *arg1 = (wxMenu *) 0 ;
33759 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33760 PyObject * obj0 = 0 ;
33761 PyObject * obj1 = 0 ;
33762 char *kwnames[] = {
33763 (char *) "self",(char *) "handler", NULL
33764 };
33765
33766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33768 if (SWIG_arg_fail(1)) SWIG_fail;
33769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33770 if (SWIG_arg_fail(2)) SWIG_fail;
33771 {
33772 PyThreadState* __tstate = wxPyBeginAllowThreads();
33773 (arg1)->SetEventHandler(arg2);
33774
33775 wxPyEndAllowThreads(__tstate);
33776 if (PyErr_Occurred()) SWIG_fail;
33777 }
33778 Py_INCREF(Py_None); resultobj = Py_None;
33779 return resultobj;
33780 fail:
33781 return NULL;
33782 }
33783
33784
33785 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33786 PyObject *resultobj;
33787 wxMenu *arg1 = (wxMenu *) 0 ;
33788 wxEvtHandler *result;
33789 PyObject * obj0 = 0 ;
33790 char *kwnames[] = {
33791 (char *) "self", NULL
33792 };
33793
33794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33796 if (SWIG_arg_fail(1)) SWIG_fail;
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33800
33801 wxPyEndAllowThreads(__tstate);
33802 if (PyErr_Occurred()) SWIG_fail;
33803 }
33804 {
33805 resultobj = wxPyMake_wxObject(result, 0);
33806 }
33807 return resultobj;
33808 fail:
33809 return NULL;
33810 }
33811
33812
33813 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33814 PyObject *resultobj;
33815 wxMenu *arg1 = (wxMenu *) 0 ;
33816 wxWindow *arg2 = (wxWindow *) 0 ;
33817 PyObject * obj0 = 0 ;
33818 PyObject * obj1 = 0 ;
33819 char *kwnames[] = {
33820 (char *) "self",(char *) "win", NULL
33821 };
33822
33823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33825 if (SWIG_arg_fail(1)) SWIG_fail;
33826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33827 if (SWIG_arg_fail(2)) SWIG_fail;
33828 {
33829 PyThreadState* __tstate = wxPyBeginAllowThreads();
33830 (arg1)->SetInvokingWindow(arg2);
33831
33832 wxPyEndAllowThreads(__tstate);
33833 if (PyErr_Occurred()) SWIG_fail;
33834 }
33835 Py_INCREF(Py_None); resultobj = Py_None;
33836 return resultobj;
33837 fail:
33838 return NULL;
33839 }
33840
33841
33842 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33843 PyObject *resultobj;
33844 wxMenu *arg1 = (wxMenu *) 0 ;
33845 wxWindow *result;
33846 PyObject * obj0 = 0 ;
33847 char *kwnames[] = {
33848 (char *) "self", NULL
33849 };
33850
33851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33853 if (SWIG_arg_fail(1)) SWIG_fail;
33854 {
33855 PyThreadState* __tstate = wxPyBeginAllowThreads();
33856 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33857
33858 wxPyEndAllowThreads(__tstate);
33859 if (PyErr_Occurred()) SWIG_fail;
33860 }
33861 {
33862 resultobj = wxPyMake_wxObject(result, 0);
33863 }
33864 return resultobj;
33865 fail:
33866 return NULL;
33867 }
33868
33869
33870 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33871 PyObject *resultobj;
33872 wxMenu *arg1 = (wxMenu *) 0 ;
33873 long result;
33874 PyObject * obj0 = 0 ;
33875 char *kwnames[] = {
33876 (char *) "self", NULL
33877 };
33878
33879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33881 if (SWIG_arg_fail(1)) SWIG_fail;
33882 {
33883 PyThreadState* __tstate = wxPyBeginAllowThreads();
33884 result = (long)((wxMenu const *)arg1)->GetStyle();
33885
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 {
33890 resultobj = SWIG_From_long((long)(result));
33891 }
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33899 PyObject *resultobj;
33900 wxMenu *arg1 = (wxMenu *) 0 ;
33901 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33902 PyObject * obj0 = 0 ;
33903 PyObject * obj1 = 0 ;
33904 char *kwnames[] = {
33905 (char *) "self",(char *) "source", NULL
33906 };
33907
33908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33910 if (SWIG_arg_fail(1)) SWIG_fail;
33911 if (obj1) {
33912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33913 if (SWIG_arg_fail(2)) SWIG_fail;
33914 }
33915 {
33916 PyThreadState* __tstate = wxPyBeginAllowThreads();
33917 (arg1)->UpdateUI(arg2);
33918
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 Py_INCREF(Py_None); resultobj = Py_None;
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj;
33931 wxMenu *arg1 = (wxMenu *) 0 ;
33932 wxMenuBar *result;
33933 PyObject * obj0 = 0 ;
33934 char *kwnames[] = {
33935 (char *) "self", NULL
33936 };
33937
33938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33940 if (SWIG_arg_fail(1)) SWIG_fail;
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33944
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 {
33949 resultobj = wxPyMake_wxObject(result, 0);
33950 }
33951 return resultobj;
33952 fail:
33953 return NULL;
33954 }
33955
33956
33957 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33958 PyObject *resultobj;
33959 wxMenu *arg1 = (wxMenu *) 0 ;
33960 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33961 PyObject * obj0 = 0 ;
33962 PyObject * obj1 = 0 ;
33963 char *kwnames[] = {
33964 (char *) "self",(char *) "menubar", NULL
33965 };
33966
33967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33969 if (SWIG_arg_fail(1)) SWIG_fail;
33970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33971 if (SWIG_arg_fail(2)) SWIG_fail;
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 (arg1)->Attach(arg2);
33975
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 Py_INCREF(Py_None); resultobj = Py_None;
33980 return resultobj;
33981 fail:
33982 return NULL;
33983 }
33984
33985
33986 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33987 PyObject *resultobj;
33988 wxMenu *arg1 = (wxMenu *) 0 ;
33989 PyObject * obj0 = 0 ;
33990 char *kwnames[] = {
33991 (char *) "self", NULL
33992 };
33993
33994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33996 if (SWIG_arg_fail(1)) SWIG_fail;
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->Detach();
34000
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 Py_INCREF(Py_None); resultobj = Py_None;
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj;
34013 wxMenu *arg1 = (wxMenu *) 0 ;
34014 bool result;
34015 PyObject * obj0 = 0 ;
34016 char *kwnames[] = {
34017 (char *) "self", NULL
34018 };
34019
34020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34022 if (SWIG_arg_fail(1)) SWIG_fail;
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (bool)((wxMenu const *)arg1)->IsAttached();
34026
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 {
34031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34032 }
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 wxMenu *arg2 = (wxMenu *) 0 ;
34043 PyObject * obj0 = 0 ;
34044 PyObject * obj1 = 0 ;
34045 char *kwnames[] = {
34046 (char *) "self",(char *) "parent", NULL
34047 };
34048
34049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34051 if (SWIG_arg_fail(1)) SWIG_fail;
34052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34053 if (SWIG_arg_fail(2)) SWIG_fail;
34054 {
34055 PyThreadState* __tstate = wxPyBeginAllowThreads();
34056 (arg1)->SetParent(arg2);
34057
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 Py_INCREF(Py_None); resultobj = Py_None;
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj;
34070 wxMenu *arg1 = (wxMenu *) 0 ;
34071 wxMenu *result;
34072 PyObject * obj0 = 0 ;
34073 char *kwnames[] = {
34074 (char *) "self", NULL
34075 };
34076
34077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34079 if (SWIG_arg_fail(1)) SWIG_fail;
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34083
34084 wxPyEndAllowThreads(__tstate);
34085 if (PyErr_Occurred()) SWIG_fail;
34086 }
34087 {
34088 resultobj = wxPyMake_wxObject(result, 0);
34089 }
34090 return resultobj;
34091 fail:
34092 return NULL;
34093 }
34094
34095
34096 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34097 PyObject *obj;
34098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34099 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34100 Py_INCREF(obj);
34101 return Py_BuildValue((char *)"");
34102 }
34103 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34104 PyObject *resultobj;
34105 long arg1 = (long) 0 ;
34106 wxMenuBar *result;
34107 PyObject * obj0 = 0 ;
34108 char *kwnames[] = {
34109 (char *) "style", NULL
34110 };
34111
34112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34113 if (obj0) {
34114 {
34115 arg1 = (long)(SWIG_As_long(obj0));
34116 if (SWIG_arg_fail(1)) SWIG_fail;
34117 }
34118 }
34119 {
34120 if (!wxPyCheckForApp()) SWIG_fail;
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = (wxMenuBar *)new wxMenuBar(arg1);
34123
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34128 return resultobj;
34129 fail:
34130 return NULL;
34131 }
34132
34133
34134 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34135 PyObject *resultobj;
34136 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34137 wxMenu *arg2 = (wxMenu *) 0 ;
34138 wxString *arg3 = 0 ;
34139 bool result;
34140 bool temp3 = false ;
34141 PyObject * obj0 = 0 ;
34142 PyObject * obj1 = 0 ;
34143 PyObject * obj2 = 0 ;
34144 char *kwnames[] = {
34145 (char *) "self",(char *) "menu",(char *) "title", NULL
34146 };
34147
34148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34150 if (SWIG_arg_fail(1)) SWIG_fail;
34151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34152 if (SWIG_arg_fail(2)) SWIG_fail;
34153 {
34154 arg3 = wxString_in_helper(obj2);
34155 if (arg3 == NULL) SWIG_fail;
34156 temp3 = true;
34157 }
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34161
34162 wxPyEndAllowThreads(__tstate);
34163 if (PyErr_Occurred()) SWIG_fail;
34164 }
34165 {
34166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34167 }
34168 {
34169 if (temp3)
34170 delete arg3;
34171 }
34172 return resultobj;
34173 fail:
34174 {
34175 if (temp3)
34176 delete arg3;
34177 }
34178 return NULL;
34179 }
34180
34181
34182 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34183 PyObject *resultobj;
34184 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34185 size_t arg2 ;
34186 wxMenu *arg3 = (wxMenu *) 0 ;
34187 wxString *arg4 = 0 ;
34188 bool result;
34189 bool temp4 = false ;
34190 PyObject * obj0 = 0 ;
34191 PyObject * obj1 = 0 ;
34192 PyObject * obj2 = 0 ;
34193 PyObject * obj3 = 0 ;
34194 char *kwnames[] = {
34195 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34196 };
34197
34198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34200 if (SWIG_arg_fail(1)) SWIG_fail;
34201 {
34202 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34203 if (SWIG_arg_fail(2)) SWIG_fail;
34204 }
34205 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34206 if (SWIG_arg_fail(3)) SWIG_fail;
34207 {
34208 arg4 = wxString_in_helper(obj3);
34209 if (arg4 == NULL) SWIG_fail;
34210 temp4 = true;
34211 }
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34215
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 {
34220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34221 }
34222 {
34223 if (temp4)
34224 delete arg4;
34225 }
34226 return resultobj;
34227 fail:
34228 {
34229 if (temp4)
34230 delete arg4;
34231 }
34232 return NULL;
34233 }
34234
34235
34236 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34237 PyObject *resultobj;
34238 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34239 size_t result;
34240 PyObject * obj0 = 0 ;
34241 char *kwnames[] = {
34242 (char *) "self", NULL
34243 };
34244
34245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34247 if (SWIG_arg_fail(1)) SWIG_fail;
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34251
34252 wxPyEndAllowThreads(__tstate);
34253 if (PyErr_Occurred()) SWIG_fail;
34254 }
34255 {
34256 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34257 }
34258 return resultobj;
34259 fail:
34260 return NULL;
34261 }
34262
34263
34264 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34265 PyObject *resultobj;
34266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34267 size_t arg2 ;
34268 wxMenu *result;
34269 PyObject * obj0 = 0 ;
34270 PyObject * obj1 = 0 ;
34271 char *kwnames[] = {
34272 (char *) "self",(char *) "pos", NULL
34273 };
34274
34275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34277 if (SWIG_arg_fail(1)) SWIG_fail;
34278 {
34279 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34280 if (SWIG_arg_fail(2)) SWIG_fail;
34281 }
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34285
34286 wxPyEndAllowThreads(__tstate);
34287 if (PyErr_Occurred()) SWIG_fail;
34288 }
34289 {
34290 resultobj = wxPyMake_wxObject(result, 0);
34291 }
34292 return resultobj;
34293 fail:
34294 return NULL;
34295 }
34296
34297
34298 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34299 PyObject *resultobj;
34300 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34301 size_t arg2 ;
34302 wxMenu *arg3 = (wxMenu *) 0 ;
34303 wxString *arg4 = 0 ;
34304 wxMenu *result;
34305 bool temp4 = false ;
34306 PyObject * obj0 = 0 ;
34307 PyObject * obj1 = 0 ;
34308 PyObject * obj2 = 0 ;
34309 PyObject * obj3 = 0 ;
34310 char *kwnames[] = {
34311 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34312 };
34313
34314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34316 if (SWIG_arg_fail(1)) SWIG_fail;
34317 {
34318 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34319 if (SWIG_arg_fail(2)) SWIG_fail;
34320 }
34321 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34322 if (SWIG_arg_fail(3)) SWIG_fail;
34323 {
34324 arg4 = wxString_in_helper(obj3);
34325 if (arg4 == NULL) SWIG_fail;
34326 temp4 = true;
34327 }
34328 {
34329 PyThreadState* __tstate = wxPyBeginAllowThreads();
34330 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34331
34332 wxPyEndAllowThreads(__tstate);
34333 if (PyErr_Occurred()) SWIG_fail;
34334 }
34335 {
34336 resultobj = wxPyMake_wxObject(result, 0);
34337 }
34338 {
34339 if (temp4)
34340 delete arg4;
34341 }
34342 return resultobj;
34343 fail:
34344 {
34345 if (temp4)
34346 delete arg4;
34347 }
34348 return NULL;
34349 }
34350
34351
34352 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34353 PyObject *resultobj;
34354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34355 size_t arg2 ;
34356 wxMenu *result;
34357 PyObject * obj0 = 0 ;
34358 PyObject * obj1 = 0 ;
34359 char *kwnames[] = {
34360 (char *) "self",(char *) "pos", NULL
34361 };
34362
34363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34365 if (SWIG_arg_fail(1)) SWIG_fail;
34366 {
34367 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34368 if (SWIG_arg_fail(2)) SWIG_fail;
34369 }
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 result = (wxMenu *)(arg1)->Remove(arg2);
34373
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 {
34378 resultobj = wxPyMake_wxObject(result, 0);
34379 }
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34387 PyObject *resultobj;
34388 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34389 size_t arg2 ;
34390 bool arg3 ;
34391 PyObject * obj0 = 0 ;
34392 PyObject * obj1 = 0 ;
34393 PyObject * obj2 = 0 ;
34394 char *kwnames[] = {
34395 (char *) "self",(char *) "pos",(char *) "enable", NULL
34396 };
34397
34398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34400 if (SWIG_arg_fail(1)) SWIG_fail;
34401 {
34402 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34403 if (SWIG_arg_fail(2)) SWIG_fail;
34404 }
34405 {
34406 arg3 = (bool)(SWIG_As_bool(obj2));
34407 if (SWIG_arg_fail(3)) SWIG_fail;
34408 }
34409 {
34410 PyThreadState* __tstate = wxPyBeginAllowThreads();
34411 (arg1)->EnableTop(arg2,arg3);
34412
34413 wxPyEndAllowThreads(__tstate);
34414 if (PyErr_Occurred()) SWIG_fail;
34415 }
34416 Py_INCREF(Py_None); resultobj = Py_None;
34417 return resultobj;
34418 fail:
34419 return NULL;
34420 }
34421
34422
34423 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34424 PyObject *resultobj;
34425 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34426 size_t arg2 ;
34427 bool result;
34428 PyObject * obj0 = 0 ;
34429 PyObject * obj1 = 0 ;
34430 char *kwnames[] = {
34431 (char *) "self",(char *) "pos", NULL
34432 };
34433
34434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34436 if (SWIG_arg_fail(1)) SWIG_fail;
34437 {
34438 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34439 if (SWIG_arg_fail(2)) SWIG_fail;
34440 }
34441 {
34442 PyThreadState* __tstate = wxPyBeginAllowThreads();
34443 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34444
34445 wxPyEndAllowThreads(__tstate);
34446 if (PyErr_Occurred()) SWIG_fail;
34447 }
34448 {
34449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34450 }
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34458 PyObject *resultobj;
34459 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34460 size_t arg2 ;
34461 wxString *arg3 = 0 ;
34462 bool temp3 = false ;
34463 PyObject * obj0 = 0 ;
34464 PyObject * obj1 = 0 ;
34465 PyObject * obj2 = 0 ;
34466 char *kwnames[] = {
34467 (char *) "self",(char *) "pos",(char *) "label", NULL
34468 };
34469
34470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34472 if (SWIG_arg_fail(1)) SWIG_fail;
34473 {
34474 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34475 if (SWIG_arg_fail(2)) SWIG_fail;
34476 }
34477 {
34478 arg3 = wxString_in_helper(obj2);
34479 if (arg3 == NULL) SWIG_fail;
34480 temp3 = true;
34481 }
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34485
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 Py_INCREF(Py_None); resultobj = Py_None;
34490 {
34491 if (temp3)
34492 delete arg3;
34493 }
34494 return resultobj;
34495 fail:
34496 {
34497 if (temp3)
34498 delete arg3;
34499 }
34500 return NULL;
34501 }
34502
34503
34504 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34505 PyObject *resultobj;
34506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34507 size_t arg2 ;
34508 wxString result;
34509 PyObject * obj0 = 0 ;
34510 PyObject * obj1 = 0 ;
34511 char *kwnames[] = {
34512 (char *) "self",(char *) "pos", NULL
34513 };
34514
34515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34517 if (SWIG_arg_fail(1)) SWIG_fail;
34518 {
34519 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34520 if (SWIG_arg_fail(2)) SWIG_fail;
34521 }
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34525
34526 wxPyEndAllowThreads(__tstate);
34527 if (PyErr_Occurred()) SWIG_fail;
34528 }
34529 {
34530 #if wxUSE_UNICODE
34531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34532 #else
34533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34534 #endif
34535 }
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj;
34544 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34545 wxString *arg2 = 0 ;
34546 wxString *arg3 = 0 ;
34547 int result;
34548 bool temp2 = false ;
34549 bool temp3 = false ;
34550 PyObject * obj0 = 0 ;
34551 PyObject * obj1 = 0 ;
34552 PyObject * obj2 = 0 ;
34553 char *kwnames[] = {
34554 (char *) "self",(char *) "menu",(char *) "item", NULL
34555 };
34556
34557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34559 if (SWIG_arg_fail(1)) SWIG_fail;
34560 {
34561 arg2 = wxString_in_helper(obj1);
34562 if (arg2 == NULL) SWIG_fail;
34563 temp2 = true;
34564 }
34565 {
34566 arg3 = wxString_in_helper(obj2);
34567 if (arg3 == NULL) SWIG_fail;
34568 temp3 = true;
34569 }
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34573
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 {
34578 resultobj = SWIG_From_int((int)(result));
34579 }
34580 {
34581 if (temp2)
34582 delete arg2;
34583 }
34584 {
34585 if (temp3)
34586 delete arg3;
34587 }
34588 return resultobj;
34589 fail:
34590 {
34591 if (temp2)
34592 delete arg2;
34593 }
34594 {
34595 if (temp3)
34596 delete arg3;
34597 }
34598 return NULL;
34599 }
34600
34601
34602 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34603 PyObject *resultobj;
34604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34605 int arg2 ;
34606 wxMenuItem *result;
34607 PyObject * obj0 = 0 ;
34608 PyObject * obj1 = 0 ;
34609 char *kwnames[] = {
34610 (char *) "self",(char *) "id", NULL
34611 };
34612
34613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34615 if (SWIG_arg_fail(1)) SWIG_fail;
34616 {
34617 arg2 = (int)(SWIG_As_int(obj1));
34618 if (SWIG_arg_fail(2)) SWIG_fail;
34619 }
34620 {
34621 PyThreadState* __tstate = wxPyBeginAllowThreads();
34622 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34623
34624 wxPyEndAllowThreads(__tstate);
34625 if (PyErr_Occurred()) SWIG_fail;
34626 }
34627 {
34628 resultobj = wxPyMake_wxObject(result, 0);
34629 }
34630 return resultobj;
34631 fail:
34632 return NULL;
34633 }
34634
34635
34636 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34637 PyObject *resultobj;
34638 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34639 wxString *arg2 = 0 ;
34640 int result;
34641 bool temp2 = false ;
34642 PyObject * obj0 = 0 ;
34643 PyObject * obj1 = 0 ;
34644 char *kwnames[] = {
34645 (char *) "self",(char *) "title", NULL
34646 };
34647
34648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34650 if (SWIG_arg_fail(1)) SWIG_fail;
34651 {
34652 arg2 = wxString_in_helper(obj1);
34653 if (arg2 == NULL) SWIG_fail;
34654 temp2 = true;
34655 }
34656 {
34657 PyThreadState* __tstate = wxPyBeginAllowThreads();
34658 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34659
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 {
34664 resultobj = SWIG_From_int((int)(result));
34665 }
34666 {
34667 if (temp2)
34668 delete arg2;
34669 }
34670 return resultobj;
34671 fail:
34672 {
34673 if (temp2)
34674 delete arg2;
34675 }
34676 return NULL;
34677 }
34678
34679
34680 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34681 PyObject *resultobj;
34682 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34683 int arg2 ;
34684 bool arg3 ;
34685 PyObject * obj0 = 0 ;
34686 PyObject * obj1 = 0 ;
34687 PyObject * obj2 = 0 ;
34688 char *kwnames[] = {
34689 (char *) "self",(char *) "id",(char *) "enable", NULL
34690 };
34691
34692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34694 if (SWIG_arg_fail(1)) SWIG_fail;
34695 {
34696 arg2 = (int)(SWIG_As_int(obj1));
34697 if (SWIG_arg_fail(2)) SWIG_fail;
34698 }
34699 {
34700 arg3 = (bool)(SWIG_As_bool(obj2));
34701 if (SWIG_arg_fail(3)) SWIG_fail;
34702 }
34703 {
34704 PyThreadState* __tstate = wxPyBeginAllowThreads();
34705 (arg1)->Enable(arg2,arg3);
34706
34707 wxPyEndAllowThreads(__tstate);
34708 if (PyErr_Occurred()) SWIG_fail;
34709 }
34710 Py_INCREF(Py_None); resultobj = Py_None;
34711 return resultobj;
34712 fail:
34713 return NULL;
34714 }
34715
34716
34717 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34718 PyObject *resultobj;
34719 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34720 int arg2 ;
34721 bool arg3 ;
34722 PyObject * obj0 = 0 ;
34723 PyObject * obj1 = 0 ;
34724 PyObject * obj2 = 0 ;
34725 char *kwnames[] = {
34726 (char *) "self",(char *) "id",(char *) "check", NULL
34727 };
34728
34729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34731 if (SWIG_arg_fail(1)) SWIG_fail;
34732 {
34733 arg2 = (int)(SWIG_As_int(obj1));
34734 if (SWIG_arg_fail(2)) SWIG_fail;
34735 }
34736 {
34737 arg3 = (bool)(SWIG_As_bool(obj2));
34738 if (SWIG_arg_fail(3)) SWIG_fail;
34739 }
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 (arg1)->Check(arg2,arg3);
34743
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 Py_INCREF(Py_None); resultobj = Py_None;
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34755 PyObject *resultobj;
34756 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34757 int arg2 ;
34758 bool result;
34759 PyObject * obj0 = 0 ;
34760 PyObject * obj1 = 0 ;
34761 char *kwnames[] = {
34762 (char *) "self",(char *) "id", NULL
34763 };
34764
34765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34767 if (SWIG_arg_fail(1)) SWIG_fail;
34768 {
34769 arg2 = (int)(SWIG_As_int(obj1));
34770 if (SWIG_arg_fail(2)) SWIG_fail;
34771 }
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34775
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 {
34780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34781 }
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34789 PyObject *resultobj;
34790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34791 int arg2 ;
34792 bool result;
34793 PyObject * obj0 = 0 ;
34794 PyObject * obj1 = 0 ;
34795 char *kwnames[] = {
34796 (char *) "self",(char *) "id", NULL
34797 };
34798
34799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34801 if (SWIG_arg_fail(1)) SWIG_fail;
34802 {
34803 arg2 = (int)(SWIG_As_int(obj1));
34804 if (SWIG_arg_fail(2)) SWIG_fail;
34805 }
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34809
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 {
34814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34815 }
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34823 PyObject *resultobj;
34824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34825 int arg2 ;
34826 wxString *arg3 = 0 ;
34827 bool temp3 = false ;
34828 PyObject * obj0 = 0 ;
34829 PyObject * obj1 = 0 ;
34830 PyObject * obj2 = 0 ;
34831 char *kwnames[] = {
34832 (char *) "self",(char *) "id",(char *) "label", NULL
34833 };
34834
34835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(1)) SWIG_fail;
34838 {
34839 arg2 = (int)(SWIG_As_int(obj1));
34840 if (SWIG_arg_fail(2)) SWIG_fail;
34841 }
34842 {
34843 arg3 = wxString_in_helper(obj2);
34844 if (arg3 == NULL) SWIG_fail;
34845 temp3 = true;
34846 }
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34850
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 Py_INCREF(Py_None); resultobj = Py_None;
34855 {
34856 if (temp3)
34857 delete arg3;
34858 }
34859 return resultobj;
34860 fail:
34861 {
34862 if (temp3)
34863 delete arg3;
34864 }
34865 return NULL;
34866 }
34867
34868
34869 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34870 PyObject *resultobj;
34871 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34872 int arg2 ;
34873 wxString result;
34874 PyObject * obj0 = 0 ;
34875 PyObject * obj1 = 0 ;
34876 char *kwnames[] = {
34877 (char *) "self",(char *) "id", NULL
34878 };
34879
34880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34882 if (SWIG_arg_fail(1)) SWIG_fail;
34883 {
34884 arg2 = (int)(SWIG_As_int(obj1));
34885 if (SWIG_arg_fail(2)) SWIG_fail;
34886 }
34887 {
34888 PyThreadState* __tstate = wxPyBeginAllowThreads();
34889 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34890
34891 wxPyEndAllowThreads(__tstate);
34892 if (PyErr_Occurred()) SWIG_fail;
34893 }
34894 {
34895 #if wxUSE_UNICODE
34896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34897 #else
34898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34899 #endif
34900 }
34901 return resultobj;
34902 fail:
34903 return NULL;
34904 }
34905
34906
34907 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj;
34909 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34910 int arg2 ;
34911 wxString *arg3 = 0 ;
34912 bool temp3 = false ;
34913 PyObject * obj0 = 0 ;
34914 PyObject * obj1 = 0 ;
34915 PyObject * obj2 = 0 ;
34916 char *kwnames[] = {
34917 (char *) "self",(char *) "id",(char *) "helpString", NULL
34918 };
34919
34920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34922 if (SWIG_arg_fail(1)) SWIG_fail;
34923 {
34924 arg2 = (int)(SWIG_As_int(obj1));
34925 if (SWIG_arg_fail(2)) SWIG_fail;
34926 }
34927 {
34928 arg3 = wxString_in_helper(obj2);
34929 if (arg3 == NULL) SWIG_fail;
34930 temp3 = true;
34931 }
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34935
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 Py_INCREF(Py_None); resultobj = Py_None;
34940 {
34941 if (temp3)
34942 delete arg3;
34943 }
34944 return resultobj;
34945 fail:
34946 {
34947 if (temp3)
34948 delete arg3;
34949 }
34950 return NULL;
34951 }
34952
34953
34954 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34955 PyObject *resultobj;
34956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34957 int arg2 ;
34958 wxString result;
34959 PyObject * obj0 = 0 ;
34960 PyObject * obj1 = 0 ;
34961 char *kwnames[] = {
34962 (char *) "self",(char *) "id", NULL
34963 };
34964
34965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34967 if (SWIG_arg_fail(1)) SWIG_fail;
34968 {
34969 arg2 = (int)(SWIG_As_int(obj1));
34970 if (SWIG_arg_fail(2)) SWIG_fail;
34971 }
34972 {
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34975
34976 wxPyEndAllowThreads(__tstate);
34977 if (PyErr_Occurred()) SWIG_fail;
34978 }
34979 {
34980 #if wxUSE_UNICODE
34981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34982 #else
34983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34984 #endif
34985 }
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj;
34994 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34995 wxFrame *result;
34996 PyObject * obj0 = 0 ;
34997 char *kwnames[] = {
34998 (char *) "self", NULL
34999 };
35000
35001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35003 if (SWIG_arg_fail(1)) SWIG_fail;
35004 {
35005 PyThreadState* __tstate = wxPyBeginAllowThreads();
35006 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35007
35008 wxPyEndAllowThreads(__tstate);
35009 if (PyErr_Occurred()) SWIG_fail;
35010 }
35011 {
35012 resultobj = wxPyMake_wxObject(result, 0);
35013 }
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj;
35022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35023 bool result;
35024 PyObject * obj0 = 0 ;
35025 char *kwnames[] = {
35026 (char *) "self", NULL
35027 };
35028
35029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35031 if (SWIG_arg_fail(1)) SWIG_fail;
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35035
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 {
35040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35041 }
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj;
35050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35051 wxFrame *arg2 = (wxFrame *) 0 ;
35052 PyObject * obj0 = 0 ;
35053 PyObject * obj1 = 0 ;
35054 char *kwnames[] = {
35055 (char *) "self",(char *) "frame", NULL
35056 };
35057
35058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35060 if (SWIG_arg_fail(1)) SWIG_fail;
35061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35062 if (SWIG_arg_fail(2)) SWIG_fail;
35063 {
35064 PyThreadState* __tstate = wxPyBeginAllowThreads();
35065 (arg1)->Attach(arg2);
35066
35067 wxPyEndAllowThreads(__tstate);
35068 if (PyErr_Occurred()) SWIG_fail;
35069 }
35070 Py_INCREF(Py_None); resultobj = Py_None;
35071 return resultobj;
35072 fail:
35073 return NULL;
35074 }
35075
35076
35077 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35078 PyObject *resultobj;
35079 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35080 PyObject * obj0 = 0 ;
35081 char *kwnames[] = {
35082 (char *) "self", NULL
35083 };
35084
35085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35087 if (SWIG_arg_fail(1)) SWIG_fail;
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 (arg1)->Detach();
35091
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 Py_INCREF(Py_None); resultobj = Py_None;
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35103 PyObject *obj;
35104 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35105 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35106 Py_INCREF(obj);
35107 return Py_BuildValue((char *)"");
35108 }
35109 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj;
35111 wxMenu *arg1 = (wxMenu *) NULL ;
35112 int arg2 = (int) wxID_ANY ;
35113 wxString const &arg3_defvalue = wxPyEmptyString ;
35114 wxString *arg3 = (wxString *) &arg3_defvalue ;
35115 wxString const &arg4_defvalue = wxPyEmptyString ;
35116 wxString *arg4 = (wxString *) &arg4_defvalue ;
35117 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35118 wxMenu *arg6 = (wxMenu *) NULL ;
35119 wxMenuItem *result;
35120 bool temp3 = false ;
35121 bool temp4 = false ;
35122 PyObject * obj0 = 0 ;
35123 PyObject * obj1 = 0 ;
35124 PyObject * obj2 = 0 ;
35125 PyObject * obj3 = 0 ;
35126 PyObject * obj4 = 0 ;
35127 PyObject * obj5 = 0 ;
35128 char *kwnames[] = {
35129 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35130 };
35131
35132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35133 if (obj0) {
35134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35135 if (SWIG_arg_fail(1)) SWIG_fail;
35136 }
35137 if (obj1) {
35138 {
35139 arg2 = (int)(SWIG_As_int(obj1));
35140 if (SWIG_arg_fail(2)) SWIG_fail;
35141 }
35142 }
35143 if (obj2) {
35144 {
35145 arg3 = wxString_in_helper(obj2);
35146 if (arg3 == NULL) SWIG_fail;
35147 temp3 = true;
35148 }
35149 }
35150 if (obj3) {
35151 {
35152 arg4 = wxString_in_helper(obj3);
35153 if (arg4 == NULL) SWIG_fail;
35154 temp4 = true;
35155 }
35156 }
35157 if (obj4) {
35158 {
35159 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35160 if (SWIG_arg_fail(5)) SWIG_fail;
35161 }
35162 }
35163 if (obj5) {
35164 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35165 if (SWIG_arg_fail(6)) SWIG_fail;
35166 }
35167 {
35168 PyThreadState* __tstate = wxPyBeginAllowThreads();
35169 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35170
35171 wxPyEndAllowThreads(__tstate);
35172 if (PyErr_Occurred()) SWIG_fail;
35173 }
35174 {
35175 resultobj = wxPyMake_wxObject(result, 1);
35176 }
35177 {
35178 if (temp3)
35179 delete arg3;
35180 }
35181 {
35182 if (temp4)
35183 delete arg4;
35184 }
35185 return resultobj;
35186 fail:
35187 {
35188 if (temp3)
35189 delete arg3;
35190 }
35191 {
35192 if (temp4)
35193 delete arg4;
35194 }
35195 return NULL;
35196 }
35197
35198
35199 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj;
35201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35202 wxMenu *result;
35203 PyObject * obj0 = 0 ;
35204 char *kwnames[] = {
35205 (char *) "self", NULL
35206 };
35207
35208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35210 if (SWIG_arg_fail(1)) SWIG_fail;
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35214
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 {
35219 resultobj = wxPyMake_wxObject(result, 0);
35220 }
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35228 PyObject *resultobj;
35229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35230 wxMenu *arg2 = (wxMenu *) 0 ;
35231 PyObject * obj0 = 0 ;
35232 PyObject * obj1 = 0 ;
35233 char *kwnames[] = {
35234 (char *) "self",(char *) "menu", NULL
35235 };
35236
35237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35239 if (SWIG_arg_fail(1)) SWIG_fail;
35240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35241 if (SWIG_arg_fail(2)) SWIG_fail;
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 (arg1)->SetMenu(arg2);
35245
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 Py_INCREF(Py_None); resultobj = Py_None;
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj;
35258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35259 int arg2 ;
35260 PyObject * obj0 = 0 ;
35261 PyObject * obj1 = 0 ;
35262 char *kwnames[] = {
35263 (char *) "self",(char *) "id", NULL
35264 };
35265
35266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35268 if (SWIG_arg_fail(1)) SWIG_fail;
35269 {
35270 arg2 = (int)(SWIG_As_int(obj1));
35271 if (SWIG_arg_fail(2)) SWIG_fail;
35272 }
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 (arg1)->SetId(arg2);
35276
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 Py_INCREF(Py_None); resultobj = Py_None;
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj;
35289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35290 int result;
35291 PyObject * obj0 = 0 ;
35292 char *kwnames[] = {
35293 (char *) "self", NULL
35294 };
35295
35296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35298 if (SWIG_arg_fail(1)) SWIG_fail;
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (int)((wxMenuItem const *)arg1)->GetId();
35302
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 {
35307 resultobj = SWIG_From_int((int)(result));
35308 }
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35316 PyObject *resultobj;
35317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35318 bool result;
35319 PyObject * obj0 = 0 ;
35320 char *kwnames[] = {
35321 (char *) "self", NULL
35322 };
35323
35324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35326 if (SWIG_arg_fail(1)) SWIG_fail;
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35330
35331 wxPyEndAllowThreads(__tstate);
35332 if (PyErr_Occurred()) SWIG_fail;
35333 }
35334 {
35335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35336 }
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35344 PyObject *resultobj;
35345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35346 wxString *arg2 = 0 ;
35347 bool temp2 = false ;
35348 PyObject * obj0 = 0 ;
35349 PyObject * obj1 = 0 ;
35350 char *kwnames[] = {
35351 (char *) "self",(char *) "str", NULL
35352 };
35353
35354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35356 if (SWIG_arg_fail(1)) SWIG_fail;
35357 {
35358 arg2 = wxString_in_helper(obj1);
35359 if (arg2 == NULL) SWIG_fail;
35360 temp2 = true;
35361 }
35362 {
35363 PyThreadState* __tstate = wxPyBeginAllowThreads();
35364 (arg1)->SetText((wxString const &)*arg2);
35365
35366 wxPyEndAllowThreads(__tstate);
35367 if (PyErr_Occurred()) SWIG_fail;
35368 }
35369 Py_INCREF(Py_None); resultobj = Py_None;
35370 {
35371 if (temp2)
35372 delete arg2;
35373 }
35374 return resultobj;
35375 fail:
35376 {
35377 if (temp2)
35378 delete arg2;
35379 }
35380 return NULL;
35381 }
35382
35383
35384 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35385 PyObject *resultobj;
35386 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35387 wxString result;
35388 PyObject * obj0 = 0 ;
35389 char *kwnames[] = {
35390 (char *) "self", NULL
35391 };
35392
35393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35395 if (SWIG_arg_fail(1)) SWIG_fail;
35396 {
35397 PyThreadState* __tstate = wxPyBeginAllowThreads();
35398 result = ((wxMenuItem const *)arg1)->GetLabel();
35399
35400 wxPyEndAllowThreads(__tstate);
35401 if (PyErr_Occurred()) SWIG_fail;
35402 }
35403 {
35404 #if wxUSE_UNICODE
35405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35406 #else
35407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35408 #endif
35409 }
35410 return resultobj;
35411 fail:
35412 return NULL;
35413 }
35414
35415
35416 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35417 PyObject *resultobj;
35418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35419 wxString *result;
35420 PyObject * obj0 = 0 ;
35421 char *kwnames[] = {
35422 (char *) "self", NULL
35423 };
35424
35425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35427 if (SWIG_arg_fail(1)) SWIG_fail;
35428 {
35429 PyThreadState* __tstate = wxPyBeginAllowThreads();
35430 {
35431 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35432 result = (wxString *) &_result_ref;
35433 }
35434
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 {
35439 #if wxUSE_UNICODE
35440 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35441 #else
35442 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35443 #endif
35444 }
35445 return resultobj;
35446 fail:
35447 return NULL;
35448 }
35449
35450
35451 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35452 PyObject *resultobj;
35453 wxString *arg1 = 0 ;
35454 wxString result;
35455 bool temp1 = false ;
35456 PyObject * obj0 = 0 ;
35457 char *kwnames[] = {
35458 (char *) "text", NULL
35459 };
35460
35461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35462 {
35463 arg1 = wxString_in_helper(obj0);
35464 if (arg1 == NULL) SWIG_fail;
35465 temp1 = true;
35466 }
35467 {
35468 PyThreadState* __tstate = wxPyBeginAllowThreads();
35469 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35470
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 {
35475 #if wxUSE_UNICODE
35476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35477 #else
35478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35479 #endif
35480 }
35481 {
35482 if (temp1)
35483 delete arg1;
35484 }
35485 return resultobj;
35486 fail:
35487 {
35488 if (temp1)
35489 delete arg1;
35490 }
35491 return NULL;
35492 }
35493
35494
35495 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35496 PyObject *resultobj;
35497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35498 wxItemKind result;
35499 PyObject * obj0 = 0 ;
35500 char *kwnames[] = {
35501 (char *) "self", NULL
35502 };
35503
35504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35506 if (SWIG_arg_fail(1)) SWIG_fail;
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35510
35511 wxPyEndAllowThreads(__tstate);
35512 if (PyErr_Occurred()) SWIG_fail;
35513 }
35514 resultobj = SWIG_From_int((result));
35515 return resultobj;
35516 fail:
35517 return NULL;
35518 }
35519
35520
35521 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35522 PyObject *resultobj;
35523 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35524 wxItemKind arg2 ;
35525 PyObject * obj0 = 0 ;
35526 PyObject * obj1 = 0 ;
35527 char *kwnames[] = {
35528 (char *) "self",(char *) "kind", NULL
35529 };
35530
35531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35533 if (SWIG_arg_fail(1)) SWIG_fail;
35534 {
35535 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35536 if (SWIG_arg_fail(2)) SWIG_fail;
35537 }
35538 {
35539 PyThreadState* __tstate = wxPyBeginAllowThreads();
35540 (arg1)->SetKind((wxItemKind )arg2);
35541
35542 wxPyEndAllowThreads(__tstate);
35543 if (PyErr_Occurred()) SWIG_fail;
35544 }
35545 Py_INCREF(Py_None); resultobj = Py_None;
35546 return resultobj;
35547 fail:
35548 return NULL;
35549 }
35550
35551
35552 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35553 PyObject *resultobj;
35554 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35555 bool arg2 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 char *kwnames[] = {
35559 (char *) "self",(char *) "checkable", NULL
35560 };
35561
35562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35564 if (SWIG_arg_fail(1)) SWIG_fail;
35565 {
35566 arg2 = (bool)(SWIG_As_bool(obj1));
35567 if (SWIG_arg_fail(2)) SWIG_fail;
35568 }
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 (arg1)->SetCheckable(arg2);
35572
35573 wxPyEndAllowThreads(__tstate);
35574 if (PyErr_Occurred()) SWIG_fail;
35575 }
35576 Py_INCREF(Py_None); resultobj = Py_None;
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35584 PyObject *resultobj;
35585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35586 bool result;
35587 PyObject * obj0 = 0 ;
35588 char *kwnames[] = {
35589 (char *) "self", NULL
35590 };
35591
35592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35594 if (SWIG_arg_fail(1)) SWIG_fail;
35595 {
35596 PyThreadState* __tstate = wxPyBeginAllowThreads();
35597 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35598
35599 wxPyEndAllowThreads(__tstate);
35600 if (PyErr_Occurred()) SWIG_fail;
35601 }
35602 {
35603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35612 PyObject *resultobj;
35613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35614 bool result;
35615 PyObject * obj0 = 0 ;
35616 char *kwnames[] = {
35617 (char *) "self", NULL
35618 };
35619
35620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35622 if (SWIG_arg_fail(1)) SWIG_fail;
35623 {
35624 PyThreadState* __tstate = wxPyBeginAllowThreads();
35625 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35626
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 {
35631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35632 }
35633 return resultobj;
35634 fail:
35635 return NULL;
35636 }
35637
35638
35639 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35640 PyObject *resultobj;
35641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35642 wxMenu *arg2 = (wxMenu *) 0 ;
35643 PyObject * obj0 = 0 ;
35644 PyObject * obj1 = 0 ;
35645 char *kwnames[] = {
35646 (char *) "self",(char *) "menu", NULL
35647 };
35648
35649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35651 if (SWIG_arg_fail(1)) SWIG_fail;
35652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35653 if (SWIG_arg_fail(2)) SWIG_fail;
35654 {
35655 PyThreadState* __tstate = wxPyBeginAllowThreads();
35656 (arg1)->SetSubMenu(arg2);
35657
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 Py_INCREF(Py_None); resultobj = Py_None;
35662 return resultobj;
35663 fail:
35664 return NULL;
35665 }
35666
35667
35668 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35669 PyObject *resultobj;
35670 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35671 wxMenu *result;
35672 PyObject * obj0 = 0 ;
35673 char *kwnames[] = {
35674 (char *) "self", NULL
35675 };
35676
35677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35679 if (SWIG_arg_fail(1)) SWIG_fail;
35680 {
35681 PyThreadState* __tstate = wxPyBeginAllowThreads();
35682 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35683
35684 wxPyEndAllowThreads(__tstate);
35685 if (PyErr_Occurred()) SWIG_fail;
35686 }
35687 {
35688 resultobj = wxPyMake_wxObject(result, 0);
35689 }
35690 return resultobj;
35691 fail:
35692 return NULL;
35693 }
35694
35695
35696 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35697 PyObject *resultobj;
35698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35699 bool arg2 = (bool) true ;
35700 PyObject * obj0 = 0 ;
35701 PyObject * obj1 = 0 ;
35702 char *kwnames[] = {
35703 (char *) "self",(char *) "enable", NULL
35704 };
35705
35706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35708 if (SWIG_arg_fail(1)) SWIG_fail;
35709 if (obj1) {
35710 {
35711 arg2 = (bool)(SWIG_As_bool(obj1));
35712 if (SWIG_arg_fail(2)) SWIG_fail;
35713 }
35714 }
35715 {
35716 PyThreadState* __tstate = wxPyBeginAllowThreads();
35717 (arg1)->Enable(arg2);
35718
35719 wxPyEndAllowThreads(__tstate);
35720 if (PyErr_Occurred()) SWIG_fail;
35721 }
35722 Py_INCREF(Py_None); resultobj = Py_None;
35723 return resultobj;
35724 fail:
35725 return NULL;
35726 }
35727
35728
35729 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35730 PyObject *resultobj;
35731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35732 bool result;
35733 PyObject * obj0 = 0 ;
35734 char *kwnames[] = {
35735 (char *) "self", NULL
35736 };
35737
35738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35740 if (SWIG_arg_fail(1)) SWIG_fail;
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35744
35745 wxPyEndAllowThreads(__tstate);
35746 if (PyErr_Occurred()) SWIG_fail;
35747 }
35748 {
35749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35750 }
35751 return resultobj;
35752 fail:
35753 return NULL;
35754 }
35755
35756
35757 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35758 PyObject *resultobj;
35759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35760 bool arg2 = (bool) true ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 char *kwnames[] = {
35764 (char *) "self",(char *) "check", NULL
35765 };
35766
35767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35769 if (SWIG_arg_fail(1)) SWIG_fail;
35770 if (obj1) {
35771 {
35772 arg2 = (bool)(SWIG_As_bool(obj1));
35773 if (SWIG_arg_fail(2)) SWIG_fail;
35774 }
35775 }
35776 {
35777 PyThreadState* __tstate = wxPyBeginAllowThreads();
35778 (arg1)->Check(arg2);
35779
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 Py_INCREF(Py_None); resultobj = Py_None;
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35791 PyObject *resultobj;
35792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35793 bool result;
35794 PyObject * obj0 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35805
35806 wxPyEndAllowThreads(__tstate);
35807 if (PyErr_Occurred()) SWIG_fail;
35808 }
35809 {
35810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35811 }
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35819 PyObject *resultobj;
35820 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35821 PyObject * obj0 = 0 ;
35822 char *kwnames[] = {
35823 (char *) "self", NULL
35824 };
35825
35826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35828 if (SWIG_arg_fail(1)) SWIG_fail;
35829 {
35830 PyThreadState* __tstate = wxPyBeginAllowThreads();
35831 (arg1)->Toggle();
35832
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 Py_INCREF(Py_None); resultobj = Py_None;
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35844 PyObject *resultobj;
35845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35846 wxString *arg2 = 0 ;
35847 bool temp2 = false ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 char *kwnames[] = {
35851 (char *) "self",(char *) "str", NULL
35852 };
35853
35854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35856 if (SWIG_arg_fail(1)) SWIG_fail;
35857 {
35858 arg2 = wxString_in_helper(obj1);
35859 if (arg2 == NULL) SWIG_fail;
35860 temp2 = true;
35861 }
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 (arg1)->SetHelp((wxString const &)*arg2);
35865
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 Py_INCREF(Py_None); resultobj = Py_None;
35870 {
35871 if (temp2)
35872 delete arg2;
35873 }
35874 return resultobj;
35875 fail:
35876 {
35877 if (temp2)
35878 delete arg2;
35879 }
35880 return NULL;
35881 }
35882
35883
35884 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35885 PyObject *resultobj;
35886 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35887 wxString *result;
35888 PyObject * obj0 = 0 ;
35889 char *kwnames[] = {
35890 (char *) "self", NULL
35891 };
35892
35893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35895 if (SWIG_arg_fail(1)) SWIG_fail;
35896 {
35897 PyThreadState* __tstate = wxPyBeginAllowThreads();
35898 {
35899 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35900 result = (wxString *) &_result_ref;
35901 }
35902
35903 wxPyEndAllowThreads(__tstate);
35904 if (PyErr_Occurred()) SWIG_fail;
35905 }
35906 {
35907 #if wxUSE_UNICODE
35908 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35909 #else
35910 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35911 #endif
35912 }
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj;
35921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35922 wxAcceleratorEntry *result;
35923 PyObject * obj0 = 0 ;
35924 char *kwnames[] = {
35925 (char *) "self", NULL
35926 };
35927
35928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35930 if (SWIG_arg_fail(1)) SWIG_fail;
35931 {
35932 PyThreadState* __tstate = wxPyBeginAllowThreads();
35933 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35934
35935 wxPyEndAllowThreads(__tstate);
35936 if (PyErr_Occurred()) SWIG_fail;
35937 }
35938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35939 return resultobj;
35940 fail:
35941 return NULL;
35942 }
35943
35944
35945 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35946 PyObject *resultobj;
35947 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35948 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35949 PyObject * obj0 = 0 ;
35950 PyObject * obj1 = 0 ;
35951 char *kwnames[] = {
35952 (char *) "self",(char *) "accel", NULL
35953 };
35954
35955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35957 if (SWIG_arg_fail(1)) SWIG_fail;
35958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35959 if (SWIG_arg_fail(2)) SWIG_fail;
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 (arg1)->SetAccel(arg2);
35963
35964 wxPyEndAllowThreads(__tstate);
35965 if (PyErr_Occurred()) SWIG_fail;
35966 }
35967 Py_INCREF(Py_None); resultobj = Py_None;
35968 return resultobj;
35969 fail:
35970 return NULL;
35971 }
35972
35973
35974 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
35975 PyObject *resultobj;
35976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35977 wxFont *arg2 = 0 ;
35978 PyObject * obj0 = 0 ;
35979 PyObject * obj1 = 0 ;
35980 char *kwnames[] = {
35981 (char *) "self",(char *) "font", NULL
35982 };
35983
35984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
35985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35986 if (SWIG_arg_fail(1)) SWIG_fail;
35987 {
35988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
35989 if (SWIG_arg_fail(2)) SWIG_fail;
35990 if (arg2 == NULL) {
35991 SWIG_null_ref("wxFont");
35992 }
35993 if (SWIG_arg_fail(2)) SWIG_fail;
35994 }
35995 {
35996 PyThreadState* __tstate = wxPyBeginAllowThreads();
35997 (arg1)->SetFont((wxFont const &)*arg2);
35998
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 Py_INCREF(Py_None); resultobj = Py_None;
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36010 PyObject *resultobj;
36011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36012 wxFont result;
36013 PyObject * obj0 = 0 ;
36014 char *kwnames[] = {
36015 (char *) "self", NULL
36016 };
36017
36018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36020 if (SWIG_arg_fail(1)) SWIG_fail;
36021 {
36022 PyThreadState* __tstate = wxPyBeginAllowThreads();
36023 result = (arg1)->GetFont();
36024
36025 wxPyEndAllowThreads(__tstate);
36026 if (PyErr_Occurred()) SWIG_fail;
36027 }
36028 {
36029 wxFont * resultptr;
36030 resultptr = new wxFont((wxFont &)(result));
36031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36032 }
36033 return resultobj;
36034 fail:
36035 return NULL;
36036 }
36037
36038
36039 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36040 PyObject *resultobj;
36041 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36042 wxColour *arg2 = 0 ;
36043 wxColour temp2 ;
36044 PyObject * obj0 = 0 ;
36045 PyObject * obj1 = 0 ;
36046 char *kwnames[] = {
36047 (char *) "self",(char *) "colText", NULL
36048 };
36049
36050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36052 if (SWIG_arg_fail(1)) SWIG_fail;
36053 {
36054 arg2 = &temp2;
36055 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36056 }
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 (arg1)->SetTextColour((wxColour const &)*arg2);
36060
36061 wxPyEndAllowThreads(__tstate);
36062 if (PyErr_Occurred()) SWIG_fail;
36063 }
36064 Py_INCREF(Py_None); resultobj = Py_None;
36065 return resultobj;
36066 fail:
36067 return NULL;
36068 }
36069
36070
36071 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36072 PyObject *resultobj;
36073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36074 wxColour result;
36075 PyObject * obj0 = 0 ;
36076 char *kwnames[] = {
36077 (char *) "self", NULL
36078 };
36079
36080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(1)) SWIG_fail;
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (arg1)->GetTextColour();
36086
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 {
36091 wxColour * resultptr;
36092 resultptr = new wxColour((wxColour &)(result));
36093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36094 }
36095 return resultobj;
36096 fail:
36097 return NULL;
36098 }
36099
36100
36101 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36102 PyObject *resultobj;
36103 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36104 wxColour *arg2 = 0 ;
36105 wxColour temp2 ;
36106 PyObject * obj0 = 0 ;
36107 PyObject * obj1 = 0 ;
36108 char *kwnames[] = {
36109 (char *) "self",(char *) "colBack", NULL
36110 };
36111
36112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36114 if (SWIG_arg_fail(1)) SWIG_fail;
36115 {
36116 arg2 = &temp2;
36117 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36118 }
36119 {
36120 PyThreadState* __tstate = wxPyBeginAllowThreads();
36121 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36122
36123 wxPyEndAllowThreads(__tstate);
36124 if (PyErr_Occurred()) SWIG_fail;
36125 }
36126 Py_INCREF(Py_None); resultobj = Py_None;
36127 return resultobj;
36128 fail:
36129 return NULL;
36130 }
36131
36132
36133 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36134 PyObject *resultobj;
36135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36136 wxColour result;
36137 PyObject * obj0 = 0 ;
36138 char *kwnames[] = {
36139 (char *) "self", NULL
36140 };
36141
36142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36144 if (SWIG_arg_fail(1)) SWIG_fail;
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 result = (arg1)->GetBackgroundColour();
36148
36149 wxPyEndAllowThreads(__tstate);
36150 if (PyErr_Occurred()) SWIG_fail;
36151 }
36152 {
36153 wxColour * resultptr;
36154 resultptr = new wxColour((wxColour &)(result));
36155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36156 }
36157 return resultobj;
36158 fail:
36159 return NULL;
36160 }
36161
36162
36163 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36164 PyObject *resultobj;
36165 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36166 wxBitmap *arg2 = 0 ;
36167 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36168 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36169 PyObject * obj0 = 0 ;
36170 PyObject * obj1 = 0 ;
36171 PyObject * obj2 = 0 ;
36172 char *kwnames[] = {
36173 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36174 };
36175
36176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36178 if (SWIG_arg_fail(1)) SWIG_fail;
36179 {
36180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36181 if (SWIG_arg_fail(2)) SWIG_fail;
36182 if (arg2 == NULL) {
36183 SWIG_null_ref("wxBitmap");
36184 }
36185 if (SWIG_arg_fail(2)) SWIG_fail;
36186 }
36187 if (obj2) {
36188 {
36189 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36190 if (SWIG_arg_fail(3)) SWIG_fail;
36191 if (arg3 == NULL) {
36192 SWIG_null_ref("wxBitmap");
36193 }
36194 if (SWIG_arg_fail(3)) SWIG_fail;
36195 }
36196 }
36197 {
36198 PyThreadState* __tstate = wxPyBeginAllowThreads();
36199 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36200
36201 wxPyEndAllowThreads(__tstate);
36202 if (PyErr_Occurred()) SWIG_fail;
36203 }
36204 Py_INCREF(Py_None); resultobj = Py_None;
36205 return resultobj;
36206 fail:
36207 return NULL;
36208 }
36209
36210
36211 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36212 PyObject *resultobj;
36213 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36214 wxBitmap *arg2 = 0 ;
36215 PyObject * obj0 = 0 ;
36216 PyObject * obj1 = 0 ;
36217 char *kwnames[] = {
36218 (char *) "self",(char *) "bmpDisabled", NULL
36219 };
36220
36221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36223 if (SWIG_arg_fail(1)) SWIG_fail;
36224 {
36225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36226 if (SWIG_arg_fail(2)) SWIG_fail;
36227 if (arg2 == NULL) {
36228 SWIG_null_ref("wxBitmap");
36229 }
36230 if (SWIG_arg_fail(2)) SWIG_fail;
36231 }
36232 {
36233 PyThreadState* __tstate = wxPyBeginAllowThreads();
36234 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36235
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 Py_INCREF(Py_None); resultobj = Py_None;
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36247 PyObject *resultobj;
36248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36249 wxBitmap *result;
36250 PyObject * obj0 = 0 ;
36251 char *kwnames[] = {
36252 (char *) "self", NULL
36253 };
36254
36255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36257 if (SWIG_arg_fail(1)) SWIG_fail;
36258 {
36259 PyThreadState* __tstate = wxPyBeginAllowThreads();
36260 {
36261 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36262 result = (wxBitmap *) &_result_ref;
36263 }
36264
36265 wxPyEndAllowThreads(__tstate);
36266 if (PyErr_Occurred()) SWIG_fail;
36267 }
36268 {
36269 wxBitmap* resultptr = new wxBitmap(*result);
36270 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36271 }
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj;
36280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36281 int arg2 ;
36282 PyObject * obj0 = 0 ;
36283 PyObject * obj1 = 0 ;
36284 char *kwnames[] = {
36285 (char *) "self",(char *) "nWidth", NULL
36286 };
36287
36288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36290 if (SWIG_arg_fail(1)) SWIG_fail;
36291 {
36292 arg2 = (int)(SWIG_As_int(obj1));
36293 if (SWIG_arg_fail(2)) SWIG_fail;
36294 }
36295 {
36296 PyThreadState* __tstate = wxPyBeginAllowThreads();
36297 (arg1)->SetMarginWidth(arg2);
36298
36299 wxPyEndAllowThreads(__tstate);
36300 if (PyErr_Occurred()) SWIG_fail;
36301 }
36302 Py_INCREF(Py_None); resultobj = Py_None;
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36310 PyObject *resultobj;
36311 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36312 int result;
36313 PyObject * obj0 = 0 ;
36314 char *kwnames[] = {
36315 (char *) "self", NULL
36316 };
36317
36318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36320 if (SWIG_arg_fail(1)) SWIG_fail;
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 result = (int)(arg1)->GetMarginWidth();
36324
36325 wxPyEndAllowThreads(__tstate);
36326 if (PyErr_Occurred()) SWIG_fail;
36327 }
36328 {
36329 resultobj = SWIG_From_int((int)(result));
36330 }
36331 return resultobj;
36332 fail:
36333 return NULL;
36334 }
36335
36336
36337 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36338 PyObject *resultobj;
36339 int result;
36340 char *kwnames[] = {
36341 NULL
36342 };
36343
36344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 result = (int)wxMenuItem::GetDefaultMarginWidth();
36348
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 resultobj = SWIG_From_int((int)(result));
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36362 PyObject *resultobj;
36363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36364 bool result;
36365 PyObject * obj0 = 0 ;
36366 char *kwnames[] = {
36367 (char *) "self", NULL
36368 };
36369
36370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36372 if (SWIG_arg_fail(1)) SWIG_fail;
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (bool)(arg1)->IsOwnerDrawn();
36376
36377 wxPyEndAllowThreads(__tstate);
36378 if (PyErr_Occurred()) SWIG_fail;
36379 }
36380 {
36381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36382 }
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36390 PyObject *resultobj;
36391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36392 bool arg2 = (bool) true ;
36393 PyObject * obj0 = 0 ;
36394 PyObject * obj1 = 0 ;
36395 char *kwnames[] = {
36396 (char *) "self",(char *) "ownerDrawn", NULL
36397 };
36398
36399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36401 if (SWIG_arg_fail(1)) SWIG_fail;
36402 if (obj1) {
36403 {
36404 arg2 = (bool)(SWIG_As_bool(obj1));
36405 if (SWIG_arg_fail(2)) SWIG_fail;
36406 }
36407 }
36408 {
36409 PyThreadState* __tstate = wxPyBeginAllowThreads();
36410 (arg1)->SetOwnerDrawn(arg2);
36411
36412 wxPyEndAllowThreads(__tstate);
36413 if (PyErr_Occurred()) SWIG_fail;
36414 }
36415 Py_INCREF(Py_None); resultobj = Py_None;
36416 return resultobj;
36417 fail:
36418 return NULL;
36419 }
36420
36421
36422 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36423 PyObject *resultobj;
36424 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36425 PyObject * obj0 = 0 ;
36426 char *kwnames[] = {
36427 (char *) "self", NULL
36428 };
36429
36430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36432 if (SWIG_arg_fail(1)) SWIG_fail;
36433 {
36434 PyThreadState* __tstate = wxPyBeginAllowThreads();
36435 (arg1)->ResetOwnerDrawn();
36436
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 Py_INCREF(Py_None); resultobj = Py_None;
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36448 PyObject *resultobj;
36449 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36450 wxBitmap *arg2 = 0 ;
36451 PyObject * obj0 = 0 ;
36452 PyObject * obj1 = 0 ;
36453 char *kwnames[] = {
36454 (char *) "self",(char *) "bitmap", NULL
36455 };
36456
36457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36459 if (SWIG_arg_fail(1)) SWIG_fail;
36460 {
36461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36462 if (SWIG_arg_fail(2)) SWIG_fail;
36463 if (arg2 == NULL) {
36464 SWIG_null_ref("wxBitmap");
36465 }
36466 if (SWIG_arg_fail(2)) SWIG_fail;
36467 }
36468 {
36469 PyThreadState* __tstate = wxPyBeginAllowThreads();
36470 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36471
36472 wxPyEndAllowThreads(__tstate);
36473 if (PyErr_Occurred()) SWIG_fail;
36474 }
36475 Py_INCREF(Py_None); resultobj = Py_None;
36476 return resultobj;
36477 fail:
36478 return NULL;
36479 }
36480
36481
36482 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj;
36484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36485 wxBitmap *result;
36486 PyObject * obj0 = 0 ;
36487 char *kwnames[] = {
36488 (char *) "self", NULL
36489 };
36490
36491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36493 if (SWIG_arg_fail(1)) SWIG_fail;
36494 {
36495 PyThreadState* __tstate = wxPyBeginAllowThreads();
36496 {
36497 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36498 result = (wxBitmap *) &_result_ref;
36499 }
36500
36501 wxPyEndAllowThreads(__tstate);
36502 if (PyErr_Occurred()) SWIG_fail;
36503 }
36504 {
36505 wxBitmap* resultptr = new wxBitmap(*result);
36506 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36507 }
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36515 PyObject *obj;
36516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36517 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36518 Py_INCREF(obj);
36519 return Py_BuildValue((char *)"");
36520 }
36521 static int _wrap_ControlNameStr_set(PyObject *) {
36522 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36523 return 1;
36524 }
36525
36526
36527 static PyObject *_wrap_ControlNameStr_get(void) {
36528 PyObject *pyobj;
36529
36530 {
36531 #if wxUSE_UNICODE
36532 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36533 #else
36534 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36535 #endif
36536 }
36537 return pyobj;
36538 }
36539
36540
36541 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj;
36543 wxWindow *arg1 = (wxWindow *) 0 ;
36544 int arg2 = (int) -1 ;
36545 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36546 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36547 wxSize const &arg4_defvalue = wxDefaultSize ;
36548 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36549 long arg5 = (long) 0 ;
36550 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36551 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36552 wxString const &arg7_defvalue = wxPyControlNameStr ;
36553 wxString *arg7 = (wxString *) &arg7_defvalue ;
36554 wxControl *result;
36555 wxPoint temp3 ;
36556 wxSize temp4 ;
36557 bool temp7 = false ;
36558 PyObject * obj0 = 0 ;
36559 PyObject * obj1 = 0 ;
36560 PyObject * obj2 = 0 ;
36561 PyObject * obj3 = 0 ;
36562 PyObject * obj4 = 0 ;
36563 PyObject * obj5 = 0 ;
36564 PyObject * obj6 = 0 ;
36565 char *kwnames[] = {
36566 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36567 };
36568
36569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36571 if (SWIG_arg_fail(1)) SWIG_fail;
36572 if (obj1) {
36573 {
36574 arg2 = (int)(SWIG_As_int(obj1));
36575 if (SWIG_arg_fail(2)) SWIG_fail;
36576 }
36577 }
36578 if (obj2) {
36579 {
36580 arg3 = &temp3;
36581 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36582 }
36583 }
36584 if (obj3) {
36585 {
36586 arg4 = &temp4;
36587 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36588 }
36589 }
36590 if (obj4) {
36591 {
36592 arg5 = (long)(SWIG_As_long(obj4));
36593 if (SWIG_arg_fail(5)) SWIG_fail;
36594 }
36595 }
36596 if (obj5) {
36597 {
36598 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36599 if (SWIG_arg_fail(6)) SWIG_fail;
36600 if (arg6 == NULL) {
36601 SWIG_null_ref("wxValidator");
36602 }
36603 if (SWIG_arg_fail(6)) SWIG_fail;
36604 }
36605 }
36606 if (obj6) {
36607 {
36608 arg7 = wxString_in_helper(obj6);
36609 if (arg7 == NULL) SWIG_fail;
36610 temp7 = true;
36611 }
36612 }
36613 {
36614 if (!wxPyCheckForApp()) SWIG_fail;
36615 PyThreadState* __tstate = wxPyBeginAllowThreads();
36616 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36617
36618 wxPyEndAllowThreads(__tstate);
36619 if (PyErr_Occurred()) SWIG_fail;
36620 }
36621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36622 {
36623 if (temp7)
36624 delete arg7;
36625 }
36626 return resultobj;
36627 fail:
36628 {
36629 if (temp7)
36630 delete arg7;
36631 }
36632 return NULL;
36633 }
36634
36635
36636 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36637 PyObject *resultobj;
36638 wxControl *result;
36639 char *kwnames[] = {
36640 NULL
36641 };
36642
36643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36644 {
36645 if (!wxPyCheckForApp()) SWIG_fail;
36646 PyThreadState* __tstate = wxPyBeginAllowThreads();
36647 result = (wxControl *)new wxControl();
36648
36649 wxPyEndAllowThreads(__tstate);
36650 if (PyErr_Occurred()) SWIG_fail;
36651 }
36652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36653 return resultobj;
36654 fail:
36655 return NULL;
36656 }
36657
36658
36659 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36660 PyObject *resultobj;
36661 wxControl *arg1 = (wxControl *) 0 ;
36662 wxWindow *arg2 = (wxWindow *) 0 ;
36663 int arg3 = (int) -1 ;
36664 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36665 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36666 wxSize const &arg5_defvalue = wxDefaultSize ;
36667 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36668 long arg6 = (long) 0 ;
36669 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36670 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36671 wxString const &arg8_defvalue = wxPyControlNameStr ;
36672 wxString *arg8 = (wxString *) &arg8_defvalue ;
36673 bool result;
36674 wxPoint temp4 ;
36675 wxSize temp5 ;
36676 bool temp8 = false ;
36677 PyObject * obj0 = 0 ;
36678 PyObject * obj1 = 0 ;
36679 PyObject * obj2 = 0 ;
36680 PyObject * obj3 = 0 ;
36681 PyObject * obj4 = 0 ;
36682 PyObject * obj5 = 0 ;
36683 PyObject * obj6 = 0 ;
36684 PyObject * obj7 = 0 ;
36685 char *kwnames[] = {
36686 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36687 };
36688
36689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36691 if (SWIG_arg_fail(1)) SWIG_fail;
36692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36693 if (SWIG_arg_fail(2)) SWIG_fail;
36694 if (obj2) {
36695 {
36696 arg3 = (int)(SWIG_As_int(obj2));
36697 if (SWIG_arg_fail(3)) SWIG_fail;
36698 }
36699 }
36700 if (obj3) {
36701 {
36702 arg4 = &temp4;
36703 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36704 }
36705 }
36706 if (obj4) {
36707 {
36708 arg5 = &temp5;
36709 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36710 }
36711 }
36712 if (obj5) {
36713 {
36714 arg6 = (long)(SWIG_As_long(obj5));
36715 if (SWIG_arg_fail(6)) SWIG_fail;
36716 }
36717 }
36718 if (obj6) {
36719 {
36720 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36721 if (SWIG_arg_fail(7)) SWIG_fail;
36722 if (arg7 == NULL) {
36723 SWIG_null_ref("wxValidator");
36724 }
36725 if (SWIG_arg_fail(7)) SWIG_fail;
36726 }
36727 }
36728 if (obj7) {
36729 {
36730 arg8 = wxString_in_helper(obj7);
36731 if (arg8 == NULL) SWIG_fail;
36732 temp8 = true;
36733 }
36734 }
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36738
36739 wxPyEndAllowThreads(__tstate);
36740 if (PyErr_Occurred()) SWIG_fail;
36741 }
36742 {
36743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36744 }
36745 {
36746 if (temp8)
36747 delete arg8;
36748 }
36749 return resultobj;
36750 fail:
36751 {
36752 if (temp8)
36753 delete arg8;
36754 }
36755 return NULL;
36756 }
36757
36758
36759 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36760 PyObject *resultobj;
36761 wxControl *arg1 = (wxControl *) 0 ;
36762 wxCommandEvent *arg2 = 0 ;
36763 PyObject * obj0 = 0 ;
36764 PyObject * obj1 = 0 ;
36765 char *kwnames[] = {
36766 (char *) "self",(char *) "event", NULL
36767 };
36768
36769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36771 if (SWIG_arg_fail(1)) SWIG_fail;
36772 {
36773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36774 if (SWIG_arg_fail(2)) SWIG_fail;
36775 if (arg2 == NULL) {
36776 SWIG_null_ref("wxCommandEvent");
36777 }
36778 if (SWIG_arg_fail(2)) SWIG_fail;
36779 }
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 (arg1)->Command(*arg2);
36783
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 Py_INCREF(Py_None); resultobj = Py_None;
36788 return resultobj;
36789 fail:
36790 return NULL;
36791 }
36792
36793
36794 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36795 PyObject *resultobj;
36796 wxControl *arg1 = (wxControl *) 0 ;
36797 wxString result;
36798 PyObject * obj0 = 0 ;
36799 char *kwnames[] = {
36800 (char *) "self", NULL
36801 };
36802
36803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36805 if (SWIG_arg_fail(1)) SWIG_fail;
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (arg1)->GetLabel();
36809
36810 wxPyEndAllowThreads(__tstate);
36811 if (PyErr_Occurred()) SWIG_fail;
36812 }
36813 {
36814 #if wxUSE_UNICODE
36815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36816 #else
36817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36818 #endif
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36827 PyObject *resultobj;
36828 wxControl *arg1 = (wxControl *) 0 ;
36829 wxString *arg2 = 0 ;
36830 bool temp2 = false ;
36831 PyObject * obj0 = 0 ;
36832 PyObject * obj1 = 0 ;
36833 char *kwnames[] = {
36834 (char *) "self",(char *) "label", NULL
36835 };
36836
36837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36839 if (SWIG_arg_fail(1)) SWIG_fail;
36840 {
36841 arg2 = wxString_in_helper(obj1);
36842 if (arg2 == NULL) SWIG_fail;
36843 temp2 = true;
36844 }
36845 {
36846 PyThreadState* __tstate = wxPyBeginAllowThreads();
36847 (arg1)->SetLabel((wxString const &)*arg2);
36848
36849 wxPyEndAllowThreads(__tstate);
36850 if (PyErr_Occurred()) SWIG_fail;
36851 }
36852 Py_INCREF(Py_None); resultobj = Py_None;
36853 {
36854 if (temp2)
36855 delete arg2;
36856 }
36857 return resultobj;
36858 fail:
36859 {
36860 if (temp2)
36861 delete arg2;
36862 }
36863 return NULL;
36864 }
36865
36866
36867 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36868 PyObject *resultobj;
36869 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36870 wxVisualAttributes result;
36871 PyObject * obj0 = 0 ;
36872 char *kwnames[] = {
36873 (char *) "variant", NULL
36874 };
36875
36876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36877 if (obj0) {
36878 {
36879 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36880 if (SWIG_arg_fail(1)) SWIG_fail;
36881 }
36882 }
36883 {
36884 if (!wxPyCheckForApp()) SWIG_fail;
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36887
36888 wxPyEndAllowThreads(__tstate);
36889 if (PyErr_Occurred()) SWIG_fail;
36890 }
36891 {
36892 wxVisualAttributes * resultptr;
36893 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36895 }
36896 return resultobj;
36897 fail:
36898 return NULL;
36899 }
36900
36901
36902 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36903 PyObject *obj;
36904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36905 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36906 Py_INCREF(obj);
36907 return Py_BuildValue((char *)"");
36908 }
36909 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36910 PyObject *resultobj;
36911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36912 wxString *arg2 = 0 ;
36913 PyObject *arg3 = (PyObject *) NULL ;
36914 int result;
36915 bool temp2 = false ;
36916 PyObject * obj0 = 0 ;
36917 PyObject * obj1 = 0 ;
36918 PyObject * obj2 = 0 ;
36919 char *kwnames[] = {
36920 (char *) "self",(char *) "item",(char *) "clientData", NULL
36921 };
36922
36923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36925 if (SWIG_arg_fail(1)) SWIG_fail;
36926 {
36927 arg2 = wxString_in_helper(obj1);
36928 if (arg2 == NULL) SWIG_fail;
36929 temp2 = true;
36930 }
36931 if (obj2) {
36932 arg3 = obj2;
36933 }
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36937
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 {
36942 resultobj = SWIG_From_int((int)(result));
36943 }
36944 {
36945 if (temp2)
36946 delete arg2;
36947 }
36948 return resultobj;
36949 fail:
36950 {
36951 if (temp2)
36952 delete arg2;
36953 }
36954 return NULL;
36955 }
36956
36957
36958 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36959 PyObject *resultobj;
36960 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36961 wxArrayString *arg2 = 0 ;
36962 bool temp2 = false ;
36963 PyObject * obj0 = 0 ;
36964 PyObject * obj1 = 0 ;
36965 char *kwnames[] = {
36966 (char *) "self",(char *) "strings", NULL
36967 };
36968
36969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36971 if (SWIG_arg_fail(1)) SWIG_fail;
36972 {
36973 if (! PySequence_Check(obj1)) {
36974 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36975 SWIG_fail;
36976 }
36977 arg2 = new wxArrayString;
36978 temp2 = true;
36979 int i, len=PySequence_Length(obj1);
36980 for (i=0; i<len; i++) {
36981 PyObject* item = PySequence_GetItem(obj1, i);
36982 #if wxUSE_UNICODE
36983 PyObject* str = PyObject_Unicode(item);
36984 #else
36985 PyObject* str = PyObject_Str(item);
36986 #endif
36987 if (PyErr_Occurred()) SWIG_fail;
36988 arg2->Add(Py2wxString(str));
36989 Py_DECREF(item);
36990 Py_DECREF(str);
36991 }
36992 }
36993 {
36994 PyThreadState* __tstate = wxPyBeginAllowThreads();
36995 (arg1)->Append((wxArrayString const &)*arg2);
36996
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 Py_INCREF(Py_None); resultobj = Py_None;
37001 {
37002 if (temp2) delete arg2;
37003 }
37004 return resultobj;
37005 fail:
37006 {
37007 if (temp2) delete arg2;
37008 }
37009 return NULL;
37010 }
37011
37012
37013 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37014 PyObject *resultobj;
37015 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37016 wxString *arg2 = 0 ;
37017 int arg3 ;
37018 PyObject *arg4 = (PyObject *) NULL ;
37019 int result;
37020 bool temp2 = false ;
37021 PyObject * obj0 = 0 ;
37022 PyObject * obj1 = 0 ;
37023 PyObject * obj2 = 0 ;
37024 PyObject * obj3 = 0 ;
37025 char *kwnames[] = {
37026 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37027 };
37028
37029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(1)) SWIG_fail;
37032 {
37033 arg2 = wxString_in_helper(obj1);
37034 if (arg2 == NULL) SWIG_fail;
37035 temp2 = true;
37036 }
37037 {
37038 arg3 = (int)(SWIG_As_int(obj2));
37039 if (SWIG_arg_fail(3)) SWIG_fail;
37040 }
37041 if (obj3) {
37042 arg4 = obj3;
37043 }
37044 {
37045 PyThreadState* __tstate = wxPyBeginAllowThreads();
37046 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37047
37048 wxPyEndAllowThreads(__tstate);
37049 if (PyErr_Occurred()) SWIG_fail;
37050 }
37051 {
37052 resultobj = SWIG_From_int((int)(result));
37053 }
37054 {
37055 if (temp2)
37056 delete arg2;
37057 }
37058 return resultobj;
37059 fail:
37060 {
37061 if (temp2)
37062 delete arg2;
37063 }
37064 return NULL;
37065 }
37066
37067
37068 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37069 PyObject *resultobj;
37070 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37071 PyObject * obj0 = 0 ;
37072 char *kwnames[] = {
37073 (char *) "self", NULL
37074 };
37075
37076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37078 if (SWIG_arg_fail(1)) SWIG_fail;
37079 {
37080 PyThreadState* __tstate = wxPyBeginAllowThreads();
37081 (arg1)->Clear();
37082
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 Py_INCREF(Py_None); resultobj = Py_None;
37087 return resultobj;
37088 fail:
37089 return NULL;
37090 }
37091
37092
37093 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37094 PyObject *resultobj;
37095 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37096 int arg2 ;
37097 PyObject * obj0 = 0 ;
37098 PyObject * obj1 = 0 ;
37099 char *kwnames[] = {
37100 (char *) "self",(char *) "n", NULL
37101 };
37102
37103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37105 if (SWIG_arg_fail(1)) SWIG_fail;
37106 {
37107 arg2 = (int)(SWIG_As_int(obj1));
37108 if (SWIG_arg_fail(2)) SWIG_fail;
37109 }
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 (arg1)->Delete(arg2);
37113
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 Py_INCREF(Py_None); resultobj = Py_None;
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj;
37126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37127 int result;
37128 PyObject * obj0 = 0 ;
37129 char *kwnames[] = {
37130 (char *) "self", NULL
37131 };
37132
37133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37135 if (SWIG_arg_fail(1)) SWIG_fail;
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 result = (int)((wxItemContainer const *)arg1)->GetCount();
37139
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 {
37144 resultobj = SWIG_From_int((int)(result));
37145 }
37146 return resultobj;
37147 fail:
37148 return NULL;
37149 }
37150
37151
37152 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37153 PyObject *resultobj;
37154 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37155 bool result;
37156 PyObject * obj0 = 0 ;
37157 char *kwnames[] = {
37158 (char *) "self", NULL
37159 };
37160
37161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37163 if (SWIG_arg_fail(1)) SWIG_fail;
37164 {
37165 PyThreadState* __tstate = wxPyBeginAllowThreads();
37166 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37167
37168 wxPyEndAllowThreads(__tstate);
37169 if (PyErr_Occurred()) SWIG_fail;
37170 }
37171 {
37172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37173 }
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj;
37182 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37183 int arg2 ;
37184 wxString result;
37185 PyObject * obj0 = 0 ;
37186 PyObject * obj1 = 0 ;
37187 char *kwnames[] = {
37188 (char *) "self",(char *) "n", NULL
37189 };
37190
37191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37193 if (SWIG_arg_fail(1)) SWIG_fail;
37194 {
37195 arg2 = (int)(SWIG_As_int(obj1));
37196 if (SWIG_arg_fail(2)) SWIG_fail;
37197 }
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37201
37202 wxPyEndAllowThreads(__tstate);
37203 if (PyErr_Occurred()) SWIG_fail;
37204 }
37205 {
37206 #if wxUSE_UNICODE
37207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37208 #else
37209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37210 #endif
37211 }
37212 return resultobj;
37213 fail:
37214 return NULL;
37215 }
37216
37217
37218 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37219 PyObject *resultobj;
37220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37221 wxArrayString result;
37222 PyObject * obj0 = 0 ;
37223 char *kwnames[] = {
37224 (char *) "self", NULL
37225 };
37226
37227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37229 if (SWIG_arg_fail(1)) SWIG_fail;
37230 {
37231 PyThreadState* __tstate = wxPyBeginAllowThreads();
37232 result = ((wxItemContainer const *)arg1)->GetStrings();
37233
37234 wxPyEndAllowThreads(__tstate);
37235 if (PyErr_Occurred()) SWIG_fail;
37236 }
37237 {
37238 resultobj = wxArrayString2PyList_helper(result);
37239 }
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj;
37248 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37249 int arg2 ;
37250 wxString *arg3 = 0 ;
37251 bool temp3 = false ;
37252 PyObject * obj0 = 0 ;
37253 PyObject * obj1 = 0 ;
37254 PyObject * obj2 = 0 ;
37255 char *kwnames[] = {
37256 (char *) "self",(char *) "n",(char *) "s", NULL
37257 };
37258
37259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37261 if (SWIG_arg_fail(1)) SWIG_fail;
37262 {
37263 arg2 = (int)(SWIG_As_int(obj1));
37264 if (SWIG_arg_fail(2)) SWIG_fail;
37265 }
37266 {
37267 arg3 = wxString_in_helper(obj2);
37268 if (arg3 == NULL) SWIG_fail;
37269 temp3 = true;
37270 }
37271 {
37272 PyThreadState* __tstate = wxPyBeginAllowThreads();
37273 (arg1)->SetString(arg2,(wxString const &)*arg3);
37274
37275 wxPyEndAllowThreads(__tstate);
37276 if (PyErr_Occurred()) SWIG_fail;
37277 }
37278 Py_INCREF(Py_None); resultobj = Py_None;
37279 {
37280 if (temp3)
37281 delete arg3;
37282 }
37283 return resultobj;
37284 fail:
37285 {
37286 if (temp3)
37287 delete arg3;
37288 }
37289 return NULL;
37290 }
37291
37292
37293 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37294 PyObject *resultobj;
37295 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37296 wxString *arg2 = 0 ;
37297 int result;
37298 bool temp2 = false ;
37299 PyObject * obj0 = 0 ;
37300 PyObject * obj1 = 0 ;
37301 char *kwnames[] = {
37302 (char *) "self",(char *) "s", NULL
37303 };
37304
37305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37307 if (SWIG_arg_fail(1)) SWIG_fail;
37308 {
37309 arg2 = wxString_in_helper(obj1);
37310 if (arg2 == NULL) SWIG_fail;
37311 temp2 = true;
37312 }
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37316
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 {
37321 resultobj = SWIG_From_int((int)(result));
37322 }
37323 {
37324 if (temp2)
37325 delete arg2;
37326 }
37327 return resultobj;
37328 fail:
37329 {
37330 if (temp2)
37331 delete arg2;
37332 }
37333 return NULL;
37334 }
37335
37336
37337 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj;
37339 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37340 int arg2 ;
37341 PyObject * obj0 = 0 ;
37342 PyObject * obj1 = 0 ;
37343 char *kwnames[] = {
37344 (char *) "self",(char *) "n", NULL
37345 };
37346
37347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37349 if (SWIG_arg_fail(1)) SWIG_fail;
37350 {
37351 arg2 = (int)(SWIG_As_int(obj1));
37352 if (SWIG_arg_fail(2)) SWIG_fail;
37353 }
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 (arg1)->Select(arg2);
37357
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 Py_INCREF(Py_None); resultobj = Py_None;
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37369 PyObject *resultobj;
37370 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37371 int result;
37372 PyObject * obj0 = 0 ;
37373 char *kwnames[] = {
37374 (char *) "self", NULL
37375 };
37376
37377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37379 if (SWIG_arg_fail(1)) SWIG_fail;
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37383
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 {
37388 resultobj = SWIG_From_int((int)(result));
37389 }
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37397 PyObject *resultobj;
37398 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37399 wxString result;
37400 PyObject * obj0 = 0 ;
37401 char *kwnames[] = {
37402 (char *) "self", NULL
37403 };
37404
37405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37407 if (SWIG_arg_fail(1)) SWIG_fail;
37408 {
37409 PyThreadState* __tstate = wxPyBeginAllowThreads();
37410 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37411
37412 wxPyEndAllowThreads(__tstate);
37413 if (PyErr_Occurred()) SWIG_fail;
37414 }
37415 {
37416 #if wxUSE_UNICODE
37417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37418 #else
37419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37420 #endif
37421 }
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37429 PyObject *resultobj;
37430 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37431 int arg2 ;
37432 PyObject *result;
37433 PyObject * obj0 = 0 ;
37434 PyObject * obj1 = 0 ;
37435 char *kwnames[] = {
37436 (char *) "self",(char *) "n", NULL
37437 };
37438
37439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37441 if (SWIG_arg_fail(1)) SWIG_fail;
37442 {
37443 arg2 = (int)(SWIG_As_int(obj1));
37444 if (SWIG_arg_fail(2)) SWIG_fail;
37445 }
37446 {
37447 PyThreadState* __tstate = wxPyBeginAllowThreads();
37448 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37449
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 resultobj = result;
37454 return resultobj;
37455 fail:
37456 return NULL;
37457 }
37458
37459
37460 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37461 PyObject *resultobj;
37462 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37463 int arg2 ;
37464 PyObject *arg3 = (PyObject *) 0 ;
37465 PyObject * obj0 = 0 ;
37466 PyObject * obj1 = 0 ;
37467 PyObject * obj2 = 0 ;
37468 char *kwnames[] = {
37469 (char *) "self",(char *) "n",(char *) "clientData", NULL
37470 };
37471
37472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37474 if (SWIG_arg_fail(1)) SWIG_fail;
37475 {
37476 arg2 = (int)(SWIG_As_int(obj1));
37477 if (SWIG_arg_fail(2)) SWIG_fail;
37478 }
37479 arg3 = obj2;
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 wxItemContainer_SetClientData(arg1,arg2,arg3);
37483
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 Py_INCREF(Py_None); resultobj = Py_None;
37488 return resultobj;
37489 fail:
37490 return NULL;
37491 }
37492
37493
37494 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37495 PyObject *obj;
37496 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37497 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37498 Py_INCREF(obj);
37499 return Py_BuildValue((char *)"");
37500 }
37501 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37502 PyObject *obj;
37503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37504 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37505 Py_INCREF(obj);
37506 return Py_BuildValue((char *)"");
37507 }
37508 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37509 PyObject *resultobj;
37510 wxSizerItem *result;
37511 char *kwnames[] = {
37512 NULL
37513 };
37514
37515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37516 {
37517 PyThreadState* __tstate = wxPyBeginAllowThreads();
37518 result = (wxSizerItem *)new wxSizerItem();
37519
37520 wxPyEndAllowThreads(__tstate);
37521 if (PyErr_Occurred()) SWIG_fail;
37522 }
37523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37531 PyObject *resultobj;
37532 wxWindow *arg1 = (wxWindow *) 0 ;
37533 int arg2 ;
37534 int arg3 ;
37535 int arg4 ;
37536 PyObject *arg5 = (PyObject *) NULL ;
37537 wxSizerItem *result;
37538 PyObject * obj0 = 0 ;
37539 PyObject * obj1 = 0 ;
37540 PyObject * obj2 = 0 ;
37541 PyObject * obj3 = 0 ;
37542 PyObject * obj4 = 0 ;
37543 char *kwnames[] = {
37544 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37545 };
37546
37547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37549 if (SWIG_arg_fail(1)) SWIG_fail;
37550 {
37551 arg2 = (int)(SWIG_As_int(obj1));
37552 if (SWIG_arg_fail(2)) SWIG_fail;
37553 }
37554 {
37555 arg3 = (int)(SWIG_As_int(obj2));
37556 if (SWIG_arg_fail(3)) SWIG_fail;
37557 }
37558 {
37559 arg4 = (int)(SWIG_As_int(obj3));
37560 if (SWIG_arg_fail(4)) SWIG_fail;
37561 }
37562 if (obj4) {
37563 arg5 = obj4;
37564 }
37565 {
37566 PyThreadState* __tstate = wxPyBeginAllowThreads();
37567 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37568
37569 wxPyEndAllowThreads(__tstate);
37570 if (PyErr_Occurred()) SWIG_fail;
37571 }
37572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37573 return resultobj;
37574 fail:
37575 return NULL;
37576 }
37577
37578
37579 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37580 PyObject *resultobj;
37581 int arg1 ;
37582 int arg2 ;
37583 int arg3 ;
37584 int arg4 ;
37585 int arg5 ;
37586 PyObject *arg6 = (PyObject *) NULL ;
37587 wxSizerItem *result;
37588 PyObject * obj0 = 0 ;
37589 PyObject * obj1 = 0 ;
37590 PyObject * obj2 = 0 ;
37591 PyObject * obj3 = 0 ;
37592 PyObject * obj4 = 0 ;
37593 PyObject * obj5 = 0 ;
37594 char *kwnames[] = {
37595 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37596 };
37597
37598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37599 {
37600 arg1 = (int)(SWIG_As_int(obj0));
37601 if (SWIG_arg_fail(1)) SWIG_fail;
37602 }
37603 {
37604 arg2 = (int)(SWIG_As_int(obj1));
37605 if (SWIG_arg_fail(2)) SWIG_fail;
37606 }
37607 {
37608 arg3 = (int)(SWIG_As_int(obj2));
37609 if (SWIG_arg_fail(3)) SWIG_fail;
37610 }
37611 {
37612 arg4 = (int)(SWIG_As_int(obj3));
37613 if (SWIG_arg_fail(4)) SWIG_fail;
37614 }
37615 {
37616 arg5 = (int)(SWIG_As_int(obj4));
37617 if (SWIG_arg_fail(5)) SWIG_fail;
37618 }
37619 if (obj5) {
37620 arg6 = obj5;
37621 }
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37625
37626 wxPyEndAllowThreads(__tstate);
37627 if (PyErr_Occurred()) SWIG_fail;
37628 }
37629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37630 return resultobj;
37631 fail:
37632 return NULL;
37633 }
37634
37635
37636 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37637 PyObject *resultobj;
37638 wxSizer *arg1 = (wxSizer *) 0 ;
37639 int arg2 ;
37640 int arg3 ;
37641 int arg4 ;
37642 PyObject *arg5 = (PyObject *) NULL ;
37643 wxSizerItem *result;
37644 PyObject * obj0 = 0 ;
37645 PyObject * obj1 = 0 ;
37646 PyObject * obj2 = 0 ;
37647 PyObject * obj3 = 0 ;
37648 PyObject * obj4 = 0 ;
37649 char *kwnames[] = {
37650 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37651 };
37652
37653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37655 if (SWIG_arg_fail(1)) SWIG_fail;
37656 {
37657 arg2 = (int)(SWIG_As_int(obj1));
37658 if (SWIG_arg_fail(2)) SWIG_fail;
37659 }
37660 {
37661 arg3 = (int)(SWIG_As_int(obj2));
37662 if (SWIG_arg_fail(3)) SWIG_fail;
37663 }
37664 {
37665 arg4 = (int)(SWIG_As_int(obj3));
37666 if (SWIG_arg_fail(4)) SWIG_fail;
37667 }
37668 if (obj4) {
37669 arg5 = obj4;
37670 }
37671 {
37672 PyThreadState* __tstate = wxPyBeginAllowThreads();
37673 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37674
37675 wxPyEndAllowThreads(__tstate);
37676 if (PyErr_Occurred()) SWIG_fail;
37677 }
37678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37679 return resultobj;
37680 fail:
37681 return NULL;
37682 }
37683
37684
37685 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37686 PyObject *resultobj;
37687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37688 PyObject * obj0 = 0 ;
37689 char *kwnames[] = {
37690 (char *) "self", NULL
37691 };
37692
37693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37695 if (SWIG_arg_fail(1)) SWIG_fail;
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 (arg1)->DeleteWindows();
37699
37700 wxPyEndAllowThreads(__tstate);
37701 if (PyErr_Occurred()) SWIG_fail;
37702 }
37703 Py_INCREF(Py_None); resultobj = Py_None;
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj;
37712 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37713 PyObject * obj0 = 0 ;
37714 char *kwnames[] = {
37715 (char *) "self", NULL
37716 };
37717
37718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37720 if (SWIG_arg_fail(1)) SWIG_fail;
37721 {
37722 PyThreadState* __tstate = wxPyBeginAllowThreads();
37723 (arg1)->DetachSizer();
37724
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 Py_INCREF(Py_None); resultobj = Py_None;
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37736 PyObject *resultobj;
37737 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37738 wxSize result;
37739 PyObject * obj0 = 0 ;
37740 char *kwnames[] = {
37741 (char *) "self", NULL
37742 };
37743
37744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37746 if (SWIG_arg_fail(1)) SWIG_fail;
37747 {
37748 PyThreadState* __tstate = wxPyBeginAllowThreads();
37749 result = (arg1)->GetSize();
37750
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 {
37755 wxSize * resultptr;
37756 resultptr = new wxSize((wxSize &)(result));
37757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37758 }
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj;
37767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37768 wxSize result;
37769 PyObject * obj0 = 0 ;
37770 char *kwnames[] = {
37771 (char *) "self", NULL
37772 };
37773
37774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37776 if (SWIG_arg_fail(1)) SWIG_fail;
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (arg1)->CalcMin();
37780
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 {
37785 wxSize * resultptr;
37786 resultptr = new wxSize((wxSize &)(result));
37787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37788 }
37789 return resultobj;
37790 fail:
37791 return NULL;
37792 }
37793
37794
37795 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37796 PyObject *resultobj;
37797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37798 wxPoint arg2 ;
37799 wxSize arg3 ;
37800 PyObject * obj0 = 0 ;
37801 PyObject * obj1 = 0 ;
37802 PyObject * obj2 = 0 ;
37803 char *kwnames[] = {
37804 (char *) "self",(char *) "pos",(char *) "size", NULL
37805 };
37806
37807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37809 if (SWIG_arg_fail(1)) SWIG_fail;
37810 {
37811 wxPoint * argp;
37812 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37813 if (SWIG_arg_fail(2)) SWIG_fail;
37814 if (argp == NULL) {
37815 SWIG_null_ref("wxPoint");
37816 }
37817 if (SWIG_arg_fail(2)) SWIG_fail;
37818 arg2 = *argp;
37819 }
37820 {
37821 wxSize * argp;
37822 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37823 if (SWIG_arg_fail(3)) SWIG_fail;
37824 if (argp == NULL) {
37825 SWIG_null_ref("wxSize");
37826 }
37827 if (SWIG_arg_fail(3)) SWIG_fail;
37828 arg3 = *argp;
37829 }
37830 {
37831 PyThreadState* __tstate = wxPyBeginAllowThreads();
37832 (arg1)->SetDimension(arg2,arg3);
37833
37834 wxPyEndAllowThreads(__tstate);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 }
37837 Py_INCREF(Py_None); resultobj = Py_None;
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj;
37846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37847 wxSize result;
37848 PyObject * obj0 = 0 ;
37849 char *kwnames[] = {
37850 (char *) "self", NULL
37851 };
37852
37853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37855 if (SWIG_arg_fail(1)) SWIG_fail;
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = (arg1)->GetMinSize();
37859
37860 wxPyEndAllowThreads(__tstate);
37861 if (PyErr_Occurred()) SWIG_fail;
37862 }
37863 {
37864 wxSize * resultptr;
37865 resultptr = new wxSize((wxSize &)(result));
37866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37867 }
37868 return resultobj;
37869 fail:
37870 return NULL;
37871 }
37872
37873
37874 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37875 PyObject *resultobj;
37876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37877 wxSize result;
37878 PyObject * obj0 = 0 ;
37879 char *kwnames[] = {
37880 (char *) "self", NULL
37881 };
37882
37883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37885 if (SWIG_arg_fail(1)) SWIG_fail;
37886 {
37887 PyThreadState* __tstate = wxPyBeginAllowThreads();
37888 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37889
37890 wxPyEndAllowThreads(__tstate);
37891 if (PyErr_Occurred()) SWIG_fail;
37892 }
37893 {
37894 wxSize * resultptr;
37895 resultptr = new wxSize((wxSize &)(result));
37896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37897 }
37898 return resultobj;
37899 fail:
37900 return NULL;
37901 }
37902
37903
37904 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37905 PyObject *resultobj;
37906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37907 int arg2 ;
37908 int arg3 ;
37909 PyObject * obj0 = 0 ;
37910 PyObject * obj1 = 0 ;
37911 PyObject * obj2 = 0 ;
37912 char *kwnames[] = {
37913 (char *) "self",(char *) "x",(char *) "y", NULL
37914 };
37915
37916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37918 if (SWIG_arg_fail(1)) SWIG_fail;
37919 {
37920 arg2 = (int)(SWIG_As_int(obj1));
37921 if (SWIG_arg_fail(2)) SWIG_fail;
37922 }
37923 {
37924 arg3 = (int)(SWIG_As_int(obj2));
37925 if (SWIG_arg_fail(3)) SWIG_fail;
37926 }
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 (arg1)->SetInitSize(arg2,arg3);
37930
37931 wxPyEndAllowThreads(__tstate);
37932 if (PyErr_Occurred()) SWIG_fail;
37933 }
37934 Py_INCREF(Py_None); resultobj = Py_None;
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37942 PyObject *resultobj;
37943 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37944 int arg2 ;
37945 int arg3 ;
37946 PyObject * obj0 = 0 ;
37947 PyObject * obj1 = 0 ;
37948 PyObject * obj2 = 0 ;
37949 char *kwnames[] = {
37950 (char *) "self",(char *) "width",(char *) "height", NULL
37951 };
37952
37953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37955 if (SWIG_arg_fail(1)) SWIG_fail;
37956 {
37957 arg2 = (int)(SWIG_As_int(obj1));
37958 if (SWIG_arg_fail(2)) SWIG_fail;
37959 }
37960 {
37961 arg3 = (int)(SWIG_As_int(obj2));
37962 if (SWIG_arg_fail(3)) SWIG_fail;
37963 }
37964 {
37965 PyThreadState* __tstate = wxPyBeginAllowThreads();
37966 (arg1)->SetRatio(arg2,arg3);
37967
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 Py_INCREF(Py_None); resultobj = Py_None;
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37979 PyObject *resultobj;
37980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37981 wxSize arg2 ;
37982 PyObject * obj0 = 0 ;
37983 PyObject * obj1 = 0 ;
37984 char *kwnames[] = {
37985 (char *) "self",(char *) "size", NULL
37986 };
37987
37988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37990 if (SWIG_arg_fail(1)) SWIG_fail;
37991 {
37992 wxSize * argp;
37993 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37994 if (SWIG_arg_fail(2)) SWIG_fail;
37995 if (argp == NULL) {
37996 SWIG_null_ref("wxSize");
37997 }
37998 if (SWIG_arg_fail(2)) SWIG_fail;
37999 arg2 = *argp;
38000 }
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 (arg1)->SetRatio(arg2);
38004
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 Py_INCREF(Py_None); resultobj = Py_None;
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38016 PyObject *resultobj;
38017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38018 float arg2 ;
38019 PyObject * obj0 = 0 ;
38020 PyObject * obj1 = 0 ;
38021 char *kwnames[] = {
38022 (char *) "self",(char *) "ratio", NULL
38023 };
38024
38025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38027 if (SWIG_arg_fail(1)) SWIG_fail;
38028 {
38029 arg2 = (float)(SWIG_As_float(obj1));
38030 if (SWIG_arg_fail(2)) SWIG_fail;
38031 }
38032 {
38033 PyThreadState* __tstate = wxPyBeginAllowThreads();
38034 (arg1)->SetRatio(arg2);
38035
38036 wxPyEndAllowThreads(__tstate);
38037 if (PyErr_Occurred()) SWIG_fail;
38038 }
38039 Py_INCREF(Py_None); resultobj = Py_None;
38040 return resultobj;
38041 fail:
38042 return NULL;
38043 }
38044
38045
38046 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38047 PyObject *resultobj;
38048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38049 float result;
38050 PyObject * obj0 = 0 ;
38051 char *kwnames[] = {
38052 (char *) "self", NULL
38053 };
38054
38055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38057 if (SWIG_arg_fail(1)) SWIG_fail;
38058 {
38059 PyThreadState* __tstate = wxPyBeginAllowThreads();
38060 result = (float)(arg1)->GetRatio();
38061
38062 wxPyEndAllowThreads(__tstate);
38063 if (PyErr_Occurred()) SWIG_fail;
38064 }
38065 {
38066 resultobj = SWIG_From_float((float)(result));
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj;
38076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38077 wxRect result;
38078 PyObject * obj0 = 0 ;
38079 char *kwnames[] = {
38080 (char *) "self", NULL
38081 };
38082
38083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38085 if (SWIG_arg_fail(1)) SWIG_fail;
38086 {
38087 PyThreadState* __tstate = wxPyBeginAllowThreads();
38088 result = (arg1)->GetRect();
38089
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 wxRect * resultptr;
38095 resultptr = new wxRect((wxRect &)(result));
38096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38097 }
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj;
38106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38107 bool result;
38108 PyObject * obj0 = 0 ;
38109 char *kwnames[] = {
38110 (char *) "self", NULL
38111 };
38112
38113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38115 if (SWIG_arg_fail(1)) SWIG_fail;
38116 {
38117 PyThreadState* __tstate = wxPyBeginAllowThreads();
38118 result = (bool)(arg1)->IsWindow();
38119
38120 wxPyEndAllowThreads(__tstate);
38121 if (PyErr_Occurred()) SWIG_fail;
38122 }
38123 {
38124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj;
38134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38135 bool result;
38136 PyObject * obj0 = 0 ;
38137 char *kwnames[] = {
38138 (char *) "self", NULL
38139 };
38140
38141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38143 if (SWIG_arg_fail(1)) SWIG_fail;
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 result = (bool)(arg1)->IsSizer();
38147
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 {
38152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38153 }
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj;
38162 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38163 bool result;
38164 PyObject * obj0 = 0 ;
38165 char *kwnames[] = {
38166 (char *) "self", NULL
38167 };
38168
38169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38171 if (SWIG_arg_fail(1)) SWIG_fail;
38172 {
38173 PyThreadState* __tstate = wxPyBeginAllowThreads();
38174 result = (bool)(arg1)->IsSpacer();
38175
38176 wxPyEndAllowThreads(__tstate);
38177 if (PyErr_Occurred()) SWIG_fail;
38178 }
38179 {
38180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38181 }
38182 return resultobj;
38183 fail:
38184 return NULL;
38185 }
38186
38187
38188 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38189 PyObject *resultobj;
38190 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38191 int arg2 ;
38192 PyObject * obj0 = 0 ;
38193 PyObject * obj1 = 0 ;
38194 char *kwnames[] = {
38195 (char *) "self",(char *) "proportion", NULL
38196 };
38197
38198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38200 if (SWIG_arg_fail(1)) SWIG_fail;
38201 {
38202 arg2 = (int)(SWIG_As_int(obj1));
38203 if (SWIG_arg_fail(2)) SWIG_fail;
38204 }
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 (arg1)->SetProportion(arg2);
38208
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 Py_INCREF(Py_None); resultobj = Py_None;
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38220 PyObject *resultobj;
38221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38222 int result;
38223 PyObject * obj0 = 0 ;
38224 char *kwnames[] = {
38225 (char *) "self", NULL
38226 };
38227
38228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38230 if (SWIG_arg_fail(1)) SWIG_fail;
38231 {
38232 PyThreadState* __tstate = wxPyBeginAllowThreads();
38233 result = (int)(arg1)->GetProportion();
38234
38235 wxPyEndAllowThreads(__tstate);
38236 if (PyErr_Occurred()) SWIG_fail;
38237 }
38238 {
38239 resultobj = SWIG_From_int((int)(result));
38240 }
38241 return resultobj;
38242 fail:
38243 return NULL;
38244 }
38245
38246
38247 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38248 PyObject *resultobj;
38249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38250 int arg2 ;
38251 PyObject * obj0 = 0 ;
38252 PyObject * obj1 = 0 ;
38253 char *kwnames[] = {
38254 (char *) "self",(char *) "flag", NULL
38255 };
38256
38257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38259 if (SWIG_arg_fail(1)) SWIG_fail;
38260 {
38261 arg2 = (int)(SWIG_As_int(obj1));
38262 if (SWIG_arg_fail(2)) SWIG_fail;
38263 }
38264 {
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 (arg1)->SetFlag(arg2);
38267
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 Py_INCREF(Py_None); resultobj = Py_None;
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38279 PyObject *resultobj;
38280 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38281 int result;
38282 PyObject * obj0 = 0 ;
38283 char *kwnames[] = {
38284 (char *) "self", NULL
38285 };
38286
38287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38289 if (SWIG_arg_fail(1)) SWIG_fail;
38290 {
38291 PyThreadState* __tstate = wxPyBeginAllowThreads();
38292 result = (int)(arg1)->GetFlag();
38293
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 {
38298 resultobj = SWIG_From_int((int)(result));
38299 }
38300 return resultobj;
38301 fail:
38302 return NULL;
38303 }
38304
38305
38306 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38307 PyObject *resultobj;
38308 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38309 int arg2 ;
38310 PyObject * obj0 = 0 ;
38311 PyObject * obj1 = 0 ;
38312 char *kwnames[] = {
38313 (char *) "self",(char *) "border", NULL
38314 };
38315
38316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38318 if (SWIG_arg_fail(1)) SWIG_fail;
38319 {
38320 arg2 = (int)(SWIG_As_int(obj1));
38321 if (SWIG_arg_fail(2)) SWIG_fail;
38322 }
38323 {
38324 PyThreadState* __tstate = wxPyBeginAllowThreads();
38325 (arg1)->SetBorder(arg2);
38326
38327 wxPyEndAllowThreads(__tstate);
38328 if (PyErr_Occurred()) SWIG_fail;
38329 }
38330 Py_INCREF(Py_None); resultobj = Py_None;
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38338 PyObject *resultobj;
38339 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38340 int result;
38341 PyObject * obj0 = 0 ;
38342 char *kwnames[] = {
38343 (char *) "self", NULL
38344 };
38345
38346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38348 if (SWIG_arg_fail(1)) SWIG_fail;
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 result = (int)(arg1)->GetBorder();
38352
38353 wxPyEndAllowThreads(__tstate);
38354 if (PyErr_Occurred()) SWIG_fail;
38355 }
38356 {
38357 resultobj = SWIG_From_int((int)(result));
38358 }
38359 return resultobj;
38360 fail:
38361 return NULL;
38362 }
38363
38364
38365 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38366 PyObject *resultobj;
38367 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38368 wxWindow *result;
38369 PyObject * obj0 = 0 ;
38370 char *kwnames[] = {
38371 (char *) "self", NULL
38372 };
38373
38374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38376 if (SWIG_arg_fail(1)) SWIG_fail;
38377 {
38378 PyThreadState* __tstate = wxPyBeginAllowThreads();
38379 result = (wxWindow *)(arg1)->GetWindow();
38380
38381 wxPyEndAllowThreads(__tstate);
38382 if (PyErr_Occurred()) SWIG_fail;
38383 }
38384 {
38385 resultobj = wxPyMake_wxObject(result, 0);
38386 }
38387 return resultobj;
38388 fail:
38389 return NULL;
38390 }
38391
38392
38393 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38394 PyObject *resultobj;
38395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38396 wxWindow *arg2 = (wxWindow *) 0 ;
38397 PyObject * obj0 = 0 ;
38398 PyObject * obj1 = 0 ;
38399 char *kwnames[] = {
38400 (char *) "self",(char *) "window", NULL
38401 };
38402
38403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38405 if (SWIG_arg_fail(1)) SWIG_fail;
38406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38407 if (SWIG_arg_fail(2)) SWIG_fail;
38408 {
38409 PyThreadState* __tstate = wxPyBeginAllowThreads();
38410 (arg1)->SetWindow(arg2);
38411
38412 wxPyEndAllowThreads(__tstate);
38413 if (PyErr_Occurred()) SWIG_fail;
38414 }
38415 Py_INCREF(Py_None); resultobj = Py_None;
38416 return resultobj;
38417 fail:
38418 return NULL;
38419 }
38420
38421
38422 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38423 PyObject *resultobj;
38424 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38425 wxSizer *result;
38426 PyObject * obj0 = 0 ;
38427 char *kwnames[] = {
38428 (char *) "self", NULL
38429 };
38430
38431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38433 if (SWIG_arg_fail(1)) SWIG_fail;
38434 {
38435 PyThreadState* __tstate = wxPyBeginAllowThreads();
38436 result = (wxSizer *)(arg1)->GetSizer();
38437
38438 wxPyEndAllowThreads(__tstate);
38439 if (PyErr_Occurred()) SWIG_fail;
38440 }
38441 {
38442 resultobj = wxPyMake_wxSizer(result, 0);
38443 }
38444 return resultobj;
38445 fail:
38446 return NULL;
38447 }
38448
38449
38450 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38451 PyObject *resultobj;
38452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38453 wxSizer *arg2 = (wxSizer *) 0 ;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 char *kwnames[] = {
38457 (char *) "self",(char *) "sizer", NULL
38458 };
38459
38460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38462 if (SWIG_arg_fail(1)) SWIG_fail;
38463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38464 if (SWIG_arg_fail(2)) SWIG_fail;
38465 {
38466 PyThreadState* __tstate = wxPyBeginAllowThreads();
38467 (arg1)->SetSizer(arg2);
38468
38469 wxPyEndAllowThreads(__tstate);
38470 if (PyErr_Occurred()) SWIG_fail;
38471 }
38472 Py_INCREF(Py_None); resultobj = Py_None;
38473 return resultobj;
38474 fail:
38475 return NULL;
38476 }
38477
38478
38479 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj;
38481 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38482 wxSize *result;
38483 PyObject * obj0 = 0 ;
38484 char *kwnames[] = {
38485 (char *) "self", NULL
38486 };
38487
38488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38490 if (SWIG_arg_fail(1)) SWIG_fail;
38491 {
38492 PyThreadState* __tstate = wxPyBeginAllowThreads();
38493 {
38494 wxSize const &_result_ref = (arg1)->GetSpacer();
38495 result = (wxSize *) &_result_ref;
38496 }
38497
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38502 return resultobj;
38503 fail:
38504 return NULL;
38505 }
38506
38507
38508 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38509 PyObject *resultobj;
38510 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38511 wxSize *arg2 = 0 ;
38512 wxSize temp2 ;
38513 PyObject * obj0 = 0 ;
38514 PyObject * obj1 = 0 ;
38515 char *kwnames[] = {
38516 (char *) "self",(char *) "size", NULL
38517 };
38518
38519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38521 if (SWIG_arg_fail(1)) SWIG_fail;
38522 {
38523 arg2 = &temp2;
38524 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38525 }
38526 {
38527 PyThreadState* __tstate = wxPyBeginAllowThreads();
38528 (arg1)->SetSpacer((wxSize const &)*arg2);
38529
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 Py_INCREF(Py_None); resultobj = Py_None;
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj;
38542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38543 bool arg2 ;
38544 PyObject * obj0 = 0 ;
38545 PyObject * obj1 = 0 ;
38546 char *kwnames[] = {
38547 (char *) "self",(char *) "show", NULL
38548 };
38549
38550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38552 if (SWIG_arg_fail(1)) SWIG_fail;
38553 {
38554 arg2 = (bool)(SWIG_As_bool(obj1));
38555 if (SWIG_arg_fail(2)) SWIG_fail;
38556 }
38557 {
38558 PyThreadState* __tstate = wxPyBeginAllowThreads();
38559 (arg1)->Show(arg2);
38560
38561 wxPyEndAllowThreads(__tstate);
38562 if (PyErr_Occurred()) SWIG_fail;
38563 }
38564 Py_INCREF(Py_None); resultobj = Py_None;
38565 return resultobj;
38566 fail:
38567 return NULL;
38568 }
38569
38570
38571 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38572 PyObject *resultobj;
38573 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38574 bool result;
38575 PyObject * obj0 = 0 ;
38576 char *kwnames[] = {
38577 (char *) "self", NULL
38578 };
38579
38580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38582 if (SWIG_arg_fail(1)) SWIG_fail;
38583 {
38584 PyThreadState* __tstate = wxPyBeginAllowThreads();
38585 result = (bool)(arg1)->IsShown();
38586
38587 wxPyEndAllowThreads(__tstate);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 }
38590 {
38591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38592 }
38593 return resultobj;
38594 fail:
38595 return NULL;
38596 }
38597
38598
38599 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38600 PyObject *resultobj;
38601 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38602 wxPoint result;
38603 PyObject * obj0 = 0 ;
38604 char *kwnames[] = {
38605 (char *) "self", NULL
38606 };
38607
38608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38610 if (SWIG_arg_fail(1)) SWIG_fail;
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (arg1)->GetPosition();
38614
38615 wxPyEndAllowThreads(__tstate);
38616 if (PyErr_Occurred()) SWIG_fail;
38617 }
38618 {
38619 wxPoint * resultptr;
38620 resultptr = new wxPoint((wxPoint &)(result));
38621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38622 }
38623 return resultobj;
38624 fail:
38625 return NULL;
38626 }
38627
38628
38629 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38630 PyObject *resultobj;
38631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38632 PyObject *result;
38633 PyObject * obj0 = 0 ;
38634 char *kwnames[] = {
38635 (char *) "self", NULL
38636 };
38637
38638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38640 if (SWIG_arg_fail(1)) SWIG_fail;
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38644
38645 wxPyEndAllowThreads(__tstate);
38646 if (PyErr_Occurred()) SWIG_fail;
38647 }
38648 resultobj = result;
38649 return resultobj;
38650 fail:
38651 return NULL;
38652 }
38653
38654
38655 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38656 PyObject *obj;
38657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38658 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38659 Py_INCREF(obj);
38660 return Py_BuildValue((char *)"");
38661 }
38662 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38663 PyObject *resultobj;
38664 wxSizer *arg1 = (wxSizer *) 0 ;
38665 PyObject *arg2 = (PyObject *) 0 ;
38666 PyObject * obj0 = 0 ;
38667 PyObject * obj1 = 0 ;
38668 char *kwnames[] = {
38669 (char *) "self",(char *) "_self", NULL
38670 };
38671
38672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38674 if (SWIG_arg_fail(1)) SWIG_fail;
38675 arg2 = obj1;
38676 {
38677 PyThreadState* __tstate = wxPyBeginAllowThreads();
38678 wxSizer__setOORInfo(arg1,arg2);
38679
38680 wxPyEndAllowThreads(__tstate);
38681 if (PyErr_Occurred()) SWIG_fail;
38682 }
38683 Py_INCREF(Py_None); resultobj = Py_None;
38684 return resultobj;
38685 fail:
38686 return NULL;
38687 }
38688
38689
38690 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38691 PyObject *resultobj;
38692 wxSizer *arg1 = (wxSizer *) 0 ;
38693 PyObject *arg2 = (PyObject *) 0 ;
38694 int arg3 = (int) 0 ;
38695 int arg4 = (int) 0 ;
38696 int arg5 = (int) 0 ;
38697 PyObject *arg6 = (PyObject *) NULL ;
38698 wxSizerItem *result;
38699 PyObject * obj0 = 0 ;
38700 PyObject * obj1 = 0 ;
38701 PyObject * obj2 = 0 ;
38702 PyObject * obj3 = 0 ;
38703 PyObject * obj4 = 0 ;
38704 PyObject * obj5 = 0 ;
38705 char *kwnames[] = {
38706 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38707 };
38708
38709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38711 if (SWIG_arg_fail(1)) SWIG_fail;
38712 arg2 = obj1;
38713 if (obj2) {
38714 {
38715 arg3 = (int)(SWIG_As_int(obj2));
38716 if (SWIG_arg_fail(3)) SWIG_fail;
38717 }
38718 }
38719 if (obj3) {
38720 {
38721 arg4 = (int)(SWIG_As_int(obj3));
38722 if (SWIG_arg_fail(4)) SWIG_fail;
38723 }
38724 }
38725 if (obj4) {
38726 {
38727 arg5 = (int)(SWIG_As_int(obj4));
38728 if (SWIG_arg_fail(5)) SWIG_fail;
38729 }
38730 }
38731 if (obj5) {
38732 arg6 = obj5;
38733 }
38734 {
38735 PyThreadState* __tstate = wxPyBeginAllowThreads();
38736 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38737
38738 wxPyEndAllowThreads(__tstate);
38739 if (PyErr_Occurred()) SWIG_fail;
38740 }
38741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38749 PyObject *resultobj;
38750 wxSizer *arg1 = (wxSizer *) 0 ;
38751 int arg2 ;
38752 PyObject *arg3 = (PyObject *) 0 ;
38753 int arg4 = (int) 0 ;
38754 int arg5 = (int) 0 ;
38755 int arg6 = (int) 0 ;
38756 PyObject *arg7 = (PyObject *) NULL ;
38757 wxSizerItem *result;
38758 PyObject * obj0 = 0 ;
38759 PyObject * obj1 = 0 ;
38760 PyObject * obj2 = 0 ;
38761 PyObject * obj3 = 0 ;
38762 PyObject * obj4 = 0 ;
38763 PyObject * obj5 = 0 ;
38764 PyObject * obj6 = 0 ;
38765 char *kwnames[] = {
38766 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38767 };
38768
38769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38771 if (SWIG_arg_fail(1)) SWIG_fail;
38772 {
38773 arg2 = (int)(SWIG_As_int(obj1));
38774 if (SWIG_arg_fail(2)) SWIG_fail;
38775 }
38776 arg3 = obj2;
38777 if (obj3) {
38778 {
38779 arg4 = (int)(SWIG_As_int(obj3));
38780 if (SWIG_arg_fail(4)) SWIG_fail;
38781 }
38782 }
38783 if (obj4) {
38784 {
38785 arg5 = (int)(SWIG_As_int(obj4));
38786 if (SWIG_arg_fail(5)) SWIG_fail;
38787 }
38788 }
38789 if (obj5) {
38790 {
38791 arg6 = (int)(SWIG_As_int(obj5));
38792 if (SWIG_arg_fail(6)) SWIG_fail;
38793 }
38794 }
38795 if (obj6) {
38796 arg7 = obj6;
38797 }
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38801
38802 wxPyEndAllowThreads(__tstate);
38803 if (PyErr_Occurred()) SWIG_fail;
38804 }
38805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38806 return resultobj;
38807 fail:
38808 return NULL;
38809 }
38810
38811
38812 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38813 PyObject *resultobj;
38814 wxSizer *arg1 = (wxSizer *) 0 ;
38815 PyObject *arg2 = (PyObject *) 0 ;
38816 int arg3 = (int) 0 ;
38817 int arg4 = (int) 0 ;
38818 int arg5 = (int) 0 ;
38819 PyObject *arg6 = (PyObject *) NULL ;
38820 wxSizerItem *result;
38821 PyObject * obj0 = 0 ;
38822 PyObject * obj1 = 0 ;
38823 PyObject * obj2 = 0 ;
38824 PyObject * obj3 = 0 ;
38825 PyObject * obj4 = 0 ;
38826 PyObject * obj5 = 0 ;
38827 char *kwnames[] = {
38828 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38829 };
38830
38831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38833 if (SWIG_arg_fail(1)) SWIG_fail;
38834 arg2 = obj1;
38835 if (obj2) {
38836 {
38837 arg3 = (int)(SWIG_As_int(obj2));
38838 if (SWIG_arg_fail(3)) SWIG_fail;
38839 }
38840 }
38841 if (obj3) {
38842 {
38843 arg4 = (int)(SWIG_As_int(obj3));
38844 if (SWIG_arg_fail(4)) SWIG_fail;
38845 }
38846 }
38847 if (obj4) {
38848 {
38849 arg5 = (int)(SWIG_As_int(obj4));
38850 if (SWIG_arg_fail(5)) SWIG_fail;
38851 }
38852 }
38853 if (obj5) {
38854 arg6 = obj5;
38855 }
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38859
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38864 return resultobj;
38865 fail:
38866 return NULL;
38867 }
38868
38869
38870 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38871 PyObject *resultobj;
38872 wxSizer *arg1 = (wxSizer *) 0 ;
38873 PyObject *arg2 = (PyObject *) 0 ;
38874 bool result;
38875 PyObject * obj0 = 0 ;
38876 PyObject * obj1 = 0 ;
38877 char *kwnames[] = {
38878 (char *) "self",(char *) "item", NULL
38879 };
38880
38881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38883 if (SWIG_arg_fail(1)) SWIG_fail;
38884 arg2 = obj1;
38885 {
38886 PyThreadState* __tstate = wxPyBeginAllowThreads();
38887 result = (bool)wxSizer_Remove(arg1,arg2);
38888
38889 wxPyEndAllowThreads(__tstate);
38890 if (PyErr_Occurred()) SWIG_fail;
38891 }
38892 {
38893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38894 }
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj;
38903 wxSizer *arg1 = (wxSizer *) 0 ;
38904 PyObject *arg2 = (PyObject *) 0 ;
38905 bool result;
38906 PyObject * obj0 = 0 ;
38907 PyObject * obj1 = 0 ;
38908 char *kwnames[] = {
38909 (char *) "self",(char *) "item", NULL
38910 };
38911
38912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38914 if (SWIG_arg_fail(1)) SWIG_fail;
38915 arg2 = obj1;
38916 {
38917 PyThreadState* __tstate = wxPyBeginAllowThreads();
38918 result = (bool)wxSizer_Detach(arg1,arg2);
38919
38920 wxPyEndAllowThreads(__tstate);
38921 if (PyErr_Occurred()) SWIG_fail;
38922 }
38923 {
38924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38925 }
38926 return resultobj;
38927 fail:
38928 return NULL;
38929 }
38930
38931
38932 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38933 PyObject *resultobj;
38934 wxSizer *arg1 = (wxSizer *) 0 ;
38935 PyObject *arg2 = (PyObject *) 0 ;
38936 wxSizerItem *result;
38937 PyObject * obj0 = 0 ;
38938 PyObject * obj1 = 0 ;
38939 char *kwnames[] = {
38940 (char *) "self",(char *) "item", NULL
38941 };
38942
38943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38945 if (SWIG_arg_fail(1)) SWIG_fail;
38946 arg2 = obj1;
38947 {
38948 PyThreadState* __tstate = wxPyBeginAllowThreads();
38949 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38950
38951 wxPyEndAllowThreads(__tstate);
38952 if (PyErr_Occurred()) SWIG_fail;
38953 }
38954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38955 return resultobj;
38956 fail:
38957 return NULL;
38958 }
38959
38960
38961 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38962 PyObject *resultobj;
38963 wxSizer *arg1 = (wxSizer *) 0 ;
38964 PyObject *arg2 = (PyObject *) 0 ;
38965 wxSize *arg3 = 0 ;
38966 wxSize temp3 ;
38967 PyObject * obj0 = 0 ;
38968 PyObject * obj1 = 0 ;
38969 PyObject * obj2 = 0 ;
38970 char *kwnames[] = {
38971 (char *) "self",(char *) "item",(char *) "size", NULL
38972 };
38973
38974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38976 if (SWIG_arg_fail(1)) SWIG_fail;
38977 arg2 = obj1;
38978 {
38979 arg3 = &temp3;
38980 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38981 }
38982 {
38983 PyThreadState* __tstate = wxPyBeginAllowThreads();
38984 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38985
38986 wxPyEndAllowThreads(__tstate);
38987 if (PyErr_Occurred()) SWIG_fail;
38988 }
38989 Py_INCREF(Py_None); resultobj = Py_None;
38990 return resultobj;
38991 fail:
38992 return NULL;
38993 }
38994
38995
38996 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38997 PyObject *resultobj;
38998 wxSizer *arg1 = (wxSizer *) 0 ;
38999 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39000 wxSizerItem *result;
39001 PyObject * obj0 = 0 ;
39002 PyObject * obj1 = 0 ;
39003 char *kwnames[] = {
39004 (char *) "self",(char *) "item", NULL
39005 };
39006
39007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39009 if (SWIG_arg_fail(1)) SWIG_fail;
39010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39011 if (SWIG_arg_fail(2)) SWIG_fail;
39012 {
39013 PyThreadState* __tstate = wxPyBeginAllowThreads();
39014 result = (wxSizerItem *)(arg1)->Add(arg2);
39015
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39020 return resultobj;
39021 fail:
39022 return NULL;
39023 }
39024
39025
39026 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39027 PyObject *resultobj;
39028 wxSizer *arg1 = (wxSizer *) 0 ;
39029 size_t arg2 ;
39030 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39031 wxSizerItem *result;
39032 PyObject * obj0 = 0 ;
39033 PyObject * obj1 = 0 ;
39034 PyObject * obj2 = 0 ;
39035 char *kwnames[] = {
39036 (char *) "self",(char *) "index",(char *) "item", NULL
39037 };
39038
39039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39041 if (SWIG_arg_fail(1)) SWIG_fail;
39042 {
39043 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39044 if (SWIG_arg_fail(2)) SWIG_fail;
39045 }
39046 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39047 if (SWIG_arg_fail(3)) SWIG_fail;
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39051
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39056 return resultobj;
39057 fail:
39058 return NULL;
39059 }
39060
39061
39062 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39063 PyObject *resultobj;
39064 wxSizer *arg1 = (wxSizer *) 0 ;
39065 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39066 wxSizerItem *result;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 char *kwnames[] = {
39070 (char *) "self",(char *) "item", NULL
39071 };
39072
39073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39075 if (SWIG_arg_fail(1)) SWIG_fail;
39076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39077 if (SWIG_arg_fail(2)) SWIG_fail;
39078 {
39079 PyThreadState* __tstate = wxPyBeginAllowThreads();
39080 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39081
39082 wxPyEndAllowThreads(__tstate);
39083 if (PyErr_Occurred()) SWIG_fail;
39084 }
39085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39093 PyObject *resultobj;
39094 wxSizer *arg1 = (wxSizer *) 0 ;
39095 int arg2 ;
39096 int arg3 ;
39097 int arg4 ;
39098 int arg5 ;
39099 PyObject * obj0 = 0 ;
39100 PyObject * obj1 = 0 ;
39101 PyObject * obj2 = 0 ;
39102 PyObject * obj3 = 0 ;
39103 PyObject * obj4 = 0 ;
39104 char *kwnames[] = {
39105 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39106 };
39107
39108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39110 if (SWIG_arg_fail(1)) SWIG_fail;
39111 {
39112 arg2 = (int)(SWIG_As_int(obj1));
39113 if (SWIG_arg_fail(2)) SWIG_fail;
39114 }
39115 {
39116 arg3 = (int)(SWIG_As_int(obj2));
39117 if (SWIG_arg_fail(3)) SWIG_fail;
39118 }
39119 {
39120 arg4 = (int)(SWIG_As_int(obj3));
39121 if (SWIG_arg_fail(4)) SWIG_fail;
39122 }
39123 {
39124 arg5 = (int)(SWIG_As_int(obj4));
39125 if (SWIG_arg_fail(5)) SWIG_fail;
39126 }
39127 {
39128 PyThreadState* __tstate = wxPyBeginAllowThreads();
39129 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39130
39131 wxPyEndAllowThreads(__tstate);
39132 if (PyErr_Occurred()) SWIG_fail;
39133 }
39134 Py_INCREF(Py_None); resultobj = Py_None;
39135 return resultobj;
39136 fail:
39137 return NULL;
39138 }
39139
39140
39141 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39142 PyObject *resultobj;
39143 wxSizer *arg1 = (wxSizer *) 0 ;
39144 wxSize *arg2 = 0 ;
39145 wxSize temp2 ;
39146 PyObject * obj0 = 0 ;
39147 PyObject * obj1 = 0 ;
39148 char *kwnames[] = {
39149 (char *) "self",(char *) "size", NULL
39150 };
39151
39152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39154 if (SWIG_arg_fail(1)) SWIG_fail;
39155 {
39156 arg2 = &temp2;
39157 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39158 }
39159 {
39160 PyThreadState* __tstate = wxPyBeginAllowThreads();
39161 (arg1)->SetMinSize((wxSize const &)*arg2);
39162
39163 wxPyEndAllowThreads(__tstate);
39164 if (PyErr_Occurred()) SWIG_fail;
39165 }
39166 Py_INCREF(Py_None); resultobj = Py_None;
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj;
39175 wxSizer *arg1 = (wxSizer *) 0 ;
39176 wxSize result;
39177 PyObject * obj0 = 0 ;
39178 char *kwnames[] = {
39179 (char *) "self", NULL
39180 };
39181
39182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39184 if (SWIG_arg_fail(1)) SWIG_fail;
39185 {
39186 PyThreadState* __tstate = wxPyBeginAllowThreads();
39187 result = (arg1)->GetSize();
39188
39189 wxPyEndAllowThreads(__tstate);
39190 if (PyErr_Occurred()) SWIG_fail;
39191 }
39192 {
39193 wxSize * resultptr;
39194 resultptr = new wxSize((wxSize &)(result));
39195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39196 }
39197 return resultobj;
39198 fail:
39199 return NULL;
39200 }
39201
39202
39203 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj;
39205 wxSizer *arg1 = (wxSizer *) 0 ;
39206 wxPoint result;
39207 PyObject * obj0 = 0 ;
39208 char *kwnames[] = {
39209 (char *) "self", NULL
39210 };
39211
39212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39214 if (SWIG_arg_fail(1)) SWIG_fail;
39215 {
39216 PyThreadState* __tstate = wxPyBeginAllowThreads();
39217 result = (arg1)->GetPosition();
39218
39219 wxPyEndAllowThreads(__tstate);
39220 if (PyErr_Occurred()) SWIG_fail;
39221 }
39222 {
39223 wxPoint * resultptr;
39224 resultptr = new wxPoint((wxPoint &)(result));
39225 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39226 }
39227 return resultobj;
39228 fail:
39229 return NULL;
39230 }
39231
39232
39233 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39234 PyObject *resultobj;
39235 wxSizer *arg1 = (wxSizer *) 0 ;
39236 wxSize result;
39237 PyObject * obj0 = 0 ;
39238 char *kwnames[] = {
39239 (char *) "self", NULL
39240 };
39241
39242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39244 if (SWIG_arg_fail(1)) SWIG_fail;
39245 {
39246 PyThreadState* __tstate = wxPyBeginAllowThreads();
39247 result = (arg1)->GetMinSize();
39248
39249 wxPyEndAllowThreads(__tstate);
39250 if (PyErr_Occurred()) SWIG_fail;
39251 }
39252 {
39253 wxSize * resultptr;
39254 resultptr = new wxSize((wxSize &)(result));
39255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39256 }
39257 return resultobj;
39258 fail:
39259 return NULL;
39260 }
39261
39262
39263 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj;
39265 wxSizer *arg1 = (wxSizer *) 0 ;
39266 PyObject * obj0 = 0 ;
39267 char *kwnames[] = {
39268 (char *) "self", NULL
39269 };
39270
39271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39273 if (SWIG_arg_fail(1)) SWIG_fail;
39274 {
39275 PyThreadState* __tstate = wxPyBeginAllowThreads();
39276 (arg1)->RecalcSizes();
39277
39278 wxPyEndAllowThreads(__tstate);
39279 if (PyErr_Occurred()) SWIG_fail;
39280 }
39281 Py_INCREF(Py_None); resultobj = Py_None;
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39289 PyObject *resultobj;
39290 wxSizer *arg1 = (wxSizer *) 0 ;
39291 wxSize result;
39292 PyObject * obj0 = 0 ;
39293 char *kwnames[] = {
39294 (char *) "self", NULL
39295 };
39296
39297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39299 if (SWIG_arg_fail(1)) SWIG_fail;
39300 {
39301 PyThreadState* __tstate = wxPyBeginAllowThreads();
39302 result = (arg1)->CalcMin();
39303
39304 wxPyEndAllowThreads(__tstate);
39305 if (PyErr_Occurred()) SWIG_fail;
39306 }
39307 {
39308 wxSize * resultptr;
39309 resultptr = new wxSize((wxSize &)(result));
39310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39311 }
39312 return resultobj;
39313 fail:
39314 return NULL;
39315 }
39316
39317
39318 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39319 PyObject *resultobj;
39320 wxSizer *arg1 = (wxSizer *) 0 ;
39321 PyObject * obj0 = 0 ;
39322 char *kwnames[] = {
39323 (char *) "self", NULL
39324 };
39325
39326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39328 if (SWIG_arg_fail(1)) SWIG_fail;
39329 {
39330 PyThreadState* __tstate = wxPyBeginAllowThreads();
39331 (arg1)->Layout();
39332
39333 wxPyEndAllowThreads(__tstate);
39334 if (PyErr_Occurred()) SWIG_fail;
39335 }
39336 Py_INCREF(Py_None); resultobj = Py_None;
39337 return resultobj;
39338 fail:
39339 return NULL;
39340 }
39341
39342
39343 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39344 PyObject *resultobj;
39345 wxSizer *arg1 = (wxSizer *) 0 ;
39346 wxWindow *arg2 = (wxWindow *) 0 ;
39347 wxSize result;
39348 PyObject * obj0 = 0 ;
39349 PyObject * obj1 = 0 ;
39350 char *kwnames[] = {
39351 (char *) "self",(char *) "window", NULL
39352 };
39353
39354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39356 if (SWIG_arg_fail(1)) SWIG_fail;
39357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39358 if (SWIG_arg_fail(2)) SWIG_fail;
39359 {
39360 PyThreadState* __tstate = wxPyBeginAllowThreads();
39361 result = (arg1)->Fit(arg2);
39362
39363 wxPyEndAllowThreads(__tstate);
39364 if (PyErr_Occurred()) SWIG_fail;
39365 }
39366 {
39367 wxSize * resultptr;
39368 resultptr = new wxSize((wxSize &)(result));
39369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39370 }
39371 return resultobj;
39372 fail:
39373 return NULL;
39374 }
39375
39376
39377 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39378 PyObject *resultobj;
39379 wxSizer *arg1 = (wxSizer *) 0 ;
39380 wxWindow *arg2 = (wxWindow *) 0 ;
39381 PyObject * obj0 = 0 ;
39382 PyObject * obj1 = 0 ;
39383 char *kwnames[] = {
39384 (char *) "self",(char *) "window", NULL
39385 };
39386
39387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39389 if (SWIG_arg_fail(1)) SWIG_fail;
39390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39391 if (SWIG_arg_fail(2)) SWIG_fail;
39392 {
39393 PyThreadState* __tstate = wxPyBeginAllowThreads();
39394 (arg1)->FitInside(arg2);
39395
39396 wxPyEndAllowThreads(__tstate);
39397 if (PyErr_Occurred()) SWIG_fail;
39398 }
39399 Py_INCREF(Py_None); resultobj = Py_None;
39400 return resultobj;
39401 fail:
39402 return NULL;
39403 }
39404
39405
39406 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39407 PyObject *resultobj;
39408 wxSizer *arg1 = (wxSizer *) 0 ;
39409 wxWindow *arg2 = (wxWindow *) 0 ;
39410 PyObject * obj0 = 0 ;
39411 PyObject * obj1 = 0 ;
39412 char *kwnames[] = {
39413 (char *) "self",(char *) "window", NULL
39414 };
39415
39416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39418 if (SWIG_arg_fail(1)) SWIG_fail;
39419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39420 if (SWIG_arg_fail(2)) SWIG_fail;
39421 {
39422 PyThreadState* __tstate = wxPyBeginAllowThreads();
39423 (arg1)->SetSizeHints(arg2);
39424
39425 wxPyEndAllowThreads(__tstate);
39426 if (PyErr_Occurred()) SWIG_fail;
39427 }
39428 Py_INCREF(Py_None); resultobj = Py_None;
39429 return resultobj;
39430 fail:
39431 return NULL;
39432 }
39433
39434
39435 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39436 PyObject *resultobj;
39437 wxSizer *arg1 = (wxSizer *) 0 ;
39438 wxWindow *arg2 = (wxWindow *) 0 ;
39439 PyObject * obj0 = 0 ;
39440 PyObject * obj1 = 0 ;
39441 char *kwnames[] = {
39442 (char *) "self",(char *) "window", NULL
39443 };
39444
39445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39447 if (SWIG_arg_fail(1)) SWIG_fail;
39448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39449 if (SWIG_arg_fail(2)) SWIG_fail;
39450 {
39451 PyThreadState* __tstate = wxPyBeginAllowThreads();
39452 (arg1)->SetVirtualSizeHints(arg2);
39453
39454 wxPyEndAllowThreads(__tstate);
39455 if (PyErr_Occurred()) SWIG_fail;
39456 }
39457 Py_INCREF(Py_None); resultobj = Py_None;
39458 return resultobj;
39459 fail:
39460 return NULL;
39461 }
39462
39463
39464 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39465 PyObject *resultobj;
39466 wxSizer *arg1 = (wxSizer *) 0 ;
39467 bool arg2 = (bool) false ;
39468 PyObject * obj0 = 0 ;
39469 PyObject * obj1 = 0 ;
39470 char *kwnames[] = {
39471 (char *) "self",(char *) "deleteWindows", NULL
39472 };
39473
39474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39476 if (SWIG_arg_fail(1)) SWIG_fail;
39477 if (obj1) {
39478 {
39479 arg2 = (bool)(SWIG_As_bool(obj1));
39480 if (SWIG_arg_fail(2)) SWIG_fail;
39481 }
39482 }
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 (arg1)->Clear(arg2);
39486
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 Py_INCREF(Py_None); resultobj = Py_None;
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj;
39499 wxSizer *arg1 = (wxSizer *) 0 ;
39500 PyObject * obj0 = 0 ;
39501 char *kwnames[] = {
39502 (char *) "self", NULL
39503 };
39504
39505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39507 if (SWIG_arg_fail(1)) SWIG_fail;
39508 {
39509 PyThreadState* __tstate = wxPyBeginAllowThreads();
39510 (arg1)->DeleteWindows();
39511
39512 wxPyEndAllowThreads(__tstate);
39513 if (PyErr_Occurred()) SWIG_fail;
39514 }
39515 Py_INCREF(Py_None); resultobj = Py_None;
39516 return resultobj;
39517 fail:
39518 return NULL;
39519 }
39520
39521
39522 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39523 PyObject *resultobj;
39524 wxSizer *arg1 = (wxSizer *) 0 ;
39525 PyObject *result;
39526 PyObject * obj0 = 0 ;
39527 char *kwnames[] = {
39528 (char *) "self", NULL
39529 };
39530
39531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39533 if (SWIG_arg_fail(1)) SWIG_fail;
39534 {
39535 PyThreadState* __tstate = wxPyBeginAllowThreads();
39536 result = (PyObject *)wxSizer_GetChildren(arg1);
39537
39538 wxPyEndAllowThreads(__tstate);
39539 if (PyErr_Occurred()) SWIG_fail;
39540 }
39541 resultobj = result;
39542 return resultobj;
39543 fail:
39544 return NULL;
39545 }
39546
39547
39548 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39549 PyObject *resultobj;
39550 wxSizer *arg1 = (wxSizer *) 0 ;
39551 PyObject *arg2 = (PyObject *) 0 ;
39552 bool arg3 = (bool) true ;
39553 bool arg4 = (bool) false ;
39554 bool result;
39555 PyObject * obj0 = 0 ;
39556 PyObject * obj1 = 0 ;
39557 PyObject * obj2 = 0 ;
39558 PyObject * obj3 = 0 ;
39559 char *kwnames[] = {
39560 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39561 };
39562
39563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39565 if (SWIG_arg_fail(1)) SWIG_fail;
39566 arg2 = obj1;
39567 if (obj2) {
39568 {
39569 arg3 = (bool)(SWIG_As_bool(obj2));
39570 if (SWIG_arg_fail(3)) SWIG_fail;
39571 }
39572 }
39573 if (obj3) {
39574 {
39575 arg4 = (bool)(SWIG_As_bool(obj3));
39576 if (SWIG_arg_fail(4)) SWIG_fail;
39577 }
39578 }
39579 {
39580 PyThreadState* __tstate = wxPyBeginAllowThreads();
39581 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39582
39583 wxPyEndAllowThreads(__tstate);
39584 if (PyErr_Occurred()) SWIG_fail;
39585 }
39586 {
39587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39588 }
39589 return resultobj;
39590 fail:
39591 return NULL;
39592 }
39593
39594
39595 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39596 PyObject *resultobj;
39597 wxSizer *arg1 = (wxSizer *) 0 ;
39598 PyObject *arg2 = (PyObject *) 0 ;
39599 bool result;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 char *kwnames[] = {
39603 (char *) "self",(char *) "item", NULL
39604 };
39605
39606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39608 if (SWIG_arg_fail(1)) SWIG_fail;
39609 arg2 = obj1;
39610 {
39611 PyThreadState* __tstate = wxPyBeginAllowThreads();
39612 result = (bool)wxSizer_IsShown(arg1,arg2);
39613
39614 wxPyEndAllowThreads(__tstate);
39615 if (PyErr_Occurred()) SWIG_fail;
39616 }
39617 {
39618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39619 }
39620 return resultobj;
39621 fail:
39622 return NULL;
39623 }
39624
39625
39626 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39627 PyObject *resultobj;
39628 wxSizer *arg1 = (wxSizer *) 0 ;
39629 bool arg2 ;
39630 PyObject * obj0 = 0 ;
39631 PyObject * obj1 = 0 ;
39632 char *kwnames[] = {
39633 (char *) "self",(char *) "show", NULL
39634 };
39635
39636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39638 if (SWIG_arg_fail(1)) SWIG_fail;
39639 {
39640 arg2 = (bool)(SWIG_As_bool(obj1));
39641 if (SWIG_arg_fail(2)) SWIG_fail;
39642 }
39643 {
39644 PyThreadState* __tstate = wxPyBeginAllowThreads();
39645 (arg1)->ShowItems(arg2);
39646
39647 wxPyEndAllowThreads(__tstate);
39648 if (PyErr_Occurred()) SWIG_fail;
39649 }
39650 Py_INCREF(Py_None); resultobj = Py_None;
39651 return resultobj;
39652 fail:
39653 return NULL;
39654 }
39655
39656
39657 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39658 PyObject *obj;
39659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39660 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39661 Py_INCREF(obj);
39662 return Py_BuildValue((char *)"");
39663 }
39664 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39665 PyObject *resultobj;
39666 wxPySizer *result;
39667 char *kwnames[] = {
39668 NULL
39669 };
39670
39671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 result = (wxPySizer *)new wxPySizer();
39675
39676 wxPyEndAllowThreads(__tstate);
39677 if (PyErr_Occurred()) SWIG_fail;
39678 }
39679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj;
39688 wxPySizer *arg1 = (wxPySizer *) 0 ;
39689 PyObject *arg2 = (PyObject *) 0 ;
39690 PyObject *arg3 = (PyObject *) 0 ;
39691 PyObject * obj0 = 0 ;
39692 PyObject * obj1 = 0 ;
39693 PyObject * obj2 = 0 ;
39694 char *kwnames[] = {
39695 (char *) "self",(char *) "self",(char *) "_class", NULL
39696 };
39697
39698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39700 if (SWIG_arg_fail(1)) SWIG_fail;
39701 arg2 = obj1;
39702 arg3 = obj2;
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 (arg1)->_setCallbackInfo(arg2,arg3);
39706
39707 wxPyEndAllowThreads(__tstate);
39708 if (PyErr_Occurred()) SWIG_fail;
39709 }
39710 Py_INCREF(Py_None); resultobj = Py_None;
39711 return resultobj;
39712 fail:
39713 return NULL;
39714 }
39715
39716
39717 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39718 PyObject *obj;
39719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39720 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39721 Py_INCREF(obj);
39722 return Py_BuildValue((char *)"");
39723 }
39724 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39725 PyObject *resultobj;
39726 int arg1 = (int) wxHORIZONTAL ;
39727 wxBoxSizer *result;
39728 PyObject * obj0 = 0 ;
39729 char *kwnames[] = {
39730 (char *) "orient", NULL
39731 };
39732
39733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39734 if (obj0) {
39735 {
39736 arg1 = (int)(SWIG_As_int(obj0));
39737 if (SWIG_arg_fail(1)) SWIG_fail;
39738 }
39739 }
39740 {
39741 PyThreadState* __tstate = wxPyBeginAllowThreads();
39742 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39743
39744 wxPyEndAllowThreads(__tstate);
39745 if (PyErr_Occurred()) SWIG_fail;
39746 }
39747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39748 return resultobj;
39749 fail:
39750 return NULL;
39751 }
39752
39753
39754 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39755 PyObject *resultobj;
39756 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39757 int result;
39758 PyObject * obj0 = 0 ;
39759 char *kwnames[] = {
39760 (char *) "self", NULL
39761 };
39762
39763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39765 if (SWIG_arg_fail(1)) SWIG_fail;
39766 {
39767 PyThreadState* __tstate = wxPyBeginAllowThreads();
39768 result = (int)(arg1)->GetOrientation();
39769
39770 wxPyEndAllowThreads(__tstate);
39771 if (PyErr_Occurred()) SWIG_fail;
39772 }
39773 {
39774 resultobj = SWIG_From_int((int)(result));
39775 }
39776 return resultobj;
39777 fail:
39778 return NULL;
39779 }
39780
39781
39782 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39783 PyObject *resultobj;
39784 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39785 int arg2 ;
39786 PyObject * obj0 = 0 ;
39787 PyObject * obj1 = 0 ;
39788 char *kwnames[] = {
39789 (char *) "self",(char *) "orient", NULL
39790 };
39791
39792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39794 if (SWIG_arg_fail(1)) SWIG_fail;
39795 {
39796 arg2 = (int)(SWIG_As_int(obj1));
39797 if (SWIG_arg_fail(2)) SWIG_fail;
39798 }
39799 {
39800 PyThreadState* __tstate = wxPyBeginAllowThreads();
39801 (arg1)->SetOrientation(arg2);
39802
39803 wxPyEndAllowThreads(__tstate);
39804 if (PyErr_Occurred()) SWIG_fail;
39805 }
39806 Py_INCREF(Py_None); resultobj = Py_None;
39807 return resultobj;
39808 fail:
39809 return NULL;
39810 }
39811
39812
39813 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39814 PyObject *obj;
39815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39816 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39817 Py_INCREF(obj);
39818 return Py_BuildValue((char *)"");
39819 }
39820 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39821 PyObject *resultobj;
39822 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39823 int arg2 = (int) wxHORIZONTAL ;
39824 wxStaticBoxSizer *result;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 char *kwnames[] = {
39828 (char *) "box",(char *) "orient", NULL
39829 };
39830
39831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39833 if (SWIG_arg_fail(1)) SWIG_fail;
39834 if (obj1) {
39835 {
39836 arg2 = (int)(SWIG_As_int(obj1));
39837 if (SWIG_arg_fail(2)) SWIG_fail;
39838 }
39839 }
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39843
39844 wxPyEndAllowThreads(__tstate);
39845 if (PyErr_Occurred()) SWIG_fail;
39846 }
39847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39848 return resultobj;
39849 fail:
39850 return NULL;
39851 }
39852
39853
39854 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39855 PyObject *resultobj;
39856 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39857 wxStaticBox *result;
39858 PyObject * obj0 = 0 ;
39859 char *kwnames[] = {
39860 (char *) "self", NULL
39861 };
39862
39863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39865 if (SWIG_arg_fail(1)) SWIG_fail;
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = (wxStaticBox *)(arg1)->GetStaticBox();
39869
39870 wxPyEndAllowThreads(__tstate);
39871 if (PyErr_Occurred()) SWIG_fail;
39872 }
39873 {
39874 resultobj = wxPyMake_wxObject(result, 0);
39875 }
39876 return resultobj;
39877 fail:
39878 return NULL;
39879 }
39880
39881
39882 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39883 PyObject *obj;
39884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39885 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39886 Py_INCREF(obj);
39887 return Py_BuildValue((char *)"");
39888 }
39889 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39890 PyObject *resultobj;
39891 int arg1 = (int) 1 ;
39892 int arg2 = (int) 0 ;
39893 int arg3 = (int) 0 ;
39894 int arg4 = (int) 0 ;
39895 wxGridSizer *result;
39896 PyObject * obj0 = 0 ;
39897 PyObject * obj1 = 0 ;
39898 PyObject * obj2 = 0 ;
39899 PyObject * obj3 = 0 ;
39900 char *kwnames[] = {
39901 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39902 };
39903
39904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39905 if (obj0) {
39906 {
39907 arg1 = (int)(SWIG_As_int(obj0));
39908 if (SWIG_arg_fail(1)) SWIG_fail;
39909 }
39910 }
39911 if (obj1) {
39912 {
39913 arg2 = (int)(SWIG_As_int(obj1));
39914 if (SWIG_arg_fail(2)) SWIG_fail;
39915 }
39916 }
39917 if (obj2) {
39918 {
39919 arg3 = (int)(SWIG_As_int(obj2));
39920 if (SWIG_arg_fail(3)) SWIG_fail;
39921 }
39922 }
39923 if (obj3) {
39924 {
39925 arg4 = (int)(SWIG_As_int(obj3));
39926 if (SWIG_arg_fail(4)) SWIG_fail;
39927 }
39928 }
39929 {
39930 PyThreadState* __tstate = wxPyBeginAllowThreads();
39931 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39932
39933 wxPyEndAllowThreads(__tstate);
39934 if (PyErr_Occurred()) SWIG_fail;
39935 }
39936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39937 return resultobj;
39938 fail:
39939 return NULL;
39940 }
39941
39942
39943 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39944 PyObject *resultobj;
39945 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39946 int arg2 ;
39947 PyObject * obj0 = 0 ;
39948 PyObject * obj1 = 0 ;
39949 char *kwnames[] = {
39950 (char *) "self",(char *) "cols", NULL
39951 };
39952
39953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39955 if (SWIG_arg_fail(1)) SWIG_fail;
39956 {
39957 arg2 = (int)(SWIG_As_int(obj1));
39958 if (SWIG_arg_fail(2)) SWIG_fail;
39959 }
39960 {
39961 PyThreadState* __tstate = wxPyBeginAllowThreads();
39962 (arg1)->SetCols(arg2);
39963
39964 wxPyEndAllowThreads(__tstate);
39965 if (PyErr_Occurred()) SWIG_fail;
39966 }
39967 Py_INCREF(Py_None); resultobj = Py_None;
39968 return resultobj;
39969 fail:
39970 return NULL;
39971 }
39972
39973
39974 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39975 PyObject *resultobj;
39976 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39977 int arg2 ;
39978 PyObject * obj0 = 0 ;
39979 PyObject * obj1 = 0 ;
39980 char *kwnames[] = {
39981 (char *) "self",(char *) "rows", NULL
39982 };
39983
39984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39986 if (SWIG_arg_fail(1)) SWIG_fail;
39987 {
39988 arg2 = (int)(SWIG_As_int(obj1));
39989 if (SWIG_arg_fail(2)) SWIG_fail;
39990 }
39991 {
39992 PyThreadState* __tstate = wxPyBeginAllowThreads();
39993 (arg1)->SetRows(arg2);
39994
39995 wxPyEndAllowThreads(__tstate);
39996 if (PyErr_Occurred()) SWIG_fail;
39997 }
39998 Py_INCREF(Py_None); resultobj = Py_None;
39999 return resultobj;
40000 fail:
40001 return NULL;
40002 }
40003
40004
40005 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40006 PyObject *resultobj;
40007 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40008 int arg2 ;
40009 PyObject * obj0 = 0 ;
40010 PyObject * obj1 = 0 ;
40011 char *kwnames[] = {
40012 (char *) "self",(char *) "gap", NULL
40013 };
40014
40015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40017 if (SWIG_arg_fail(1)) SWIG_fail;
40018 {
40019 arg2 = (int)(SWIG_As_int(obj1));
40020 if (SWIG_arg_fail(2)) SWIG_fail;
40021 }
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 (arg1)->SetVGap(arg2);
40025
40026 wxPyEndAllowThreads(__tstate);
40027 if (PyErr_Occurred()) SWIG_fail;
40028 }
40029 Py_INCREF(Py_None); resultobj = Py_None;
40030 return resultobj;
40031 fail:
40032 return NULL;
40033 }
40034
40035
40036 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40037 PyObject *resultobj;
40038 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40039 int arg2 ;
40040 PyObject * obj0 = 0 ;
40041 PyObject * obj1 = 0 ;
40042 char *kwnames[] = {
40043 (char *) "self",(char *) "gap", NULL
40044 };
40045
40046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40048 if (SWIG_arg_fail(1)) SWIG_fail;
40049 {
40050 arg2 = (int)(SWIG_As_int(obj1));
40051 if (SWIG_arg_fail(2)) SWIG_fail;
40052 }
40053 {
40054 PyThreadState* __tstate = wxPyBeginAllowThreads();
40055 (arg1)->SetHGap(arg2);
40056
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 Py_INCREF(Py_None); resultobj = Py_None;
40061 return resultobj;
40062 fail:
40063 return NULL;
40064 }
40065
40066
40067 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40068 PyObject *resultobj;
40069 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40070 int result;
40071 PyObject * obj0 = 0 ;
40072 char *kwnames[] = {
40073 (char *) "self", NULL
40074 };
40075
40076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40078 if (SWIG_arg_fail(1)) SWIG_fail;
40079 {
40080 PyThreadState* __tstate = wxPyBeginAllowThreads();
40081 result = (int)(arg1)->GetCols();
40082
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 {
40087 resultobj = SWIG_From_int((int)(result));
40088 }
40089 return resultobj;
40090 fail:
40091 return NULL;
40092 }
40093
40094
40095 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40096 PyObject *resultobj;
40097 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40098 int result;
40099 PyObject * obj0 = 0 ;
40100 char *kwnames[] = {
40101 (char *) "self", NULL
40102 };
40103
40104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40106 if (SWIG_arg_fail(1)) SWIG_fail;
40107 {
40108 PyThreadState* __tstate = wxPyBeginAllowThreads();
40109 result = (int)(arg1)->GetRows();
40110
40111 wxPyEndAllowThreads(__tstate);
40112 if (PyErr_Occurred()) SWIG_fail;
40113 }
40114 {
40115 resultobj = SWIG_From_int((int)(result));
40116 }
40117 return resultobj;
40118 fail:
40119 return NULL;
40120 }
40121
40122
40123 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40124 PyObject *resultobj;
40125 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40126 int result;
40127 PyObject * obj0 = 0 ;
40128 char *kwnames[] = {
40129 (char *) "self", NULL
40130 };
40131
40132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40134 if (SWIG_arg_fail(1)) SWIG_fail;
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 result = (int)(arg1)->GetVGap();
40138
40139 wxPyEndAllowThreads(__tstate);
40140 if (PyErr_Occurred()) SWIG_fail;
40141 }
40142 {
40143 resultobj = SWIG_From_int((int)(result));
40144 }
40145 return resultobj;
40146 fail:
40147 return NULL;
40148 }
40149
40150
40151 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40152 PyObject *resultobj;
40153 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40154 int result;
40155 PyObject * obj0 = 0 ;
40156 char *kwnames[] = {
40157 (char *) "self", NULL
40158 };
40159
40160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40162 if (SWIG_arg_fail(1)) SWIG_fail;
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 result = (int)(arg1)->GetHGap();
40166
40167 wxPyEndAllowThreads(__tstate);
40168 if (PyErr_Occurred()) SWIG_fail;
40169 }
40170 {
40171 resultobj = SWIG_From_int((int)(result));
40172 }
40173 return resultobj;
40174 fail:
40175 return NULL;
40176 }
40177
40178
40179 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40180 PyObject *obj;
40181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40182 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40183 Py_INCREF(obj);
40184 return Py_BuildValue((char *)"");
40185 }
40186 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40187 PyObject *resultobj;
40188 int arg1 = (int) 1 ;
40189 int arg2 = (int) 0 ;
40190 int arg3 = (int) 0 ;
40191 int arg4 = (int) 0 ;
40192 wxFlexGridSizer *result;
40193 PyObject * obj0 = 0 ;
40194 PyObject * obj1 = 0 ;
40195 PyObject * obj2 = 0 ;
40196 PyObject * obj3 = 0 ;
40197 char *kwnames[] = {
40198 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40199 };
40200
40201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40202 if (obj0) {
40203 {
40204 arg1 = (int)(SWIG_As_int(obj0));
40205 if (SWIG_arg_fail(1)) SWIG_fail;
40206 }
40207 }
40208 if (obj1) {
40209 {
40210 arg2 = (int)(SWIG_As_int(obj1));
40211 if (SWIG_arg_fail(2)) SWIG_fail;
40212 }
40213 }
40214 if (obj2) {
40215 {
40216 arg3 = (int)(SWIG_As_int(obj2));
40217 if (SWIG_arg_fail(3)) SWIG_fail;
40218 }
40219 }
40220 if (obj3) {
40221 {
40222 arg4 = (int)(SWIG_As_int(obj3));
40223 if (SWIG_arg_fail(4)) SWIG_fail;
40224 }
40225 }
40226 {
40227 PyThreadState* __tstate = wxPyBeginAllowThreads();
40228 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40229
40230 wxPyEndAllowThreads(__tstate);
40231 if (PyErr_Occurred()) SWIG_fail;
40232 }
40233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40234 return resultobj;
40235 fail:
40236 return NULL;
40237 }
40238
40239
40240 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40241 PyObject *resultobj;
40242 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40243 size_t arg2 ;
40244 int arg3 = (int) 0 ;
40245 PyObject * obj0 = 0 ;
40246 PyObject * obj1 = 0 ;
40247 PyObject * obj2 = 0 ;
40248 char *kwnames[] = {
40249 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40250 };
40251
40252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40254 if (SWIG_arg_fail(1)) SWIG_fail;
40255 {
40256 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40257 if (SWIG_arg_fail(2)) SWIG_fail;
40258 }
40259 if (obj2) {
40260 {
40261 arg3 = (int)(SWIG_As_int(obj2));
40262 if (SWIG_arg_fail(3)) SWIG_fail;
40263 }
40264 }
40265 {
40266 PyThreadState* __tstate = wxPyBeginAllowThreads();
40267 (arg1)->AddGrowableRow(arg2,arg3);
40268
40269 wxPyEndAllowThreads(__tstate);
40270 if (PyErr_Occurred()) SWIG_fail;
40271 }
40272 Py_INCREF(Py_None); resultobj = Py_None;
40273 return resultobj;
40274 fail:
40275 return NULL;
40276 }
40277
40278
40279 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40280 PyObject *resultobj;
40281 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40282 size_t arg2 ;
40283 PyObject * obj0 = 0 ;
40284 PyObject * obj1 = 0 ;
40285 char *kwnames[] = {
40286 (char *) "self",(char *) "idx", NULL
40287 };
40288
40289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40291 if (SWIG_arg_fail(1)) SWIG_fail;
40292 {
40293 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40294 if (SWIG_arg_fail(2)) SWIG_fail;
40295 }
40296 {
40297 PyThreadState* __tstate = wxPyBeginAllowThreads();
40298 (arg1)->RemoveGrowableRow(arg2);
40299
40300 wxPyEndAllowThreads(__tstate);
40301 if (PyErr_Occurred()) SWIG_fail;
40302 }
40303 Py_INCREF(Py_None); resultobj = Py_None;
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj;
40312 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40313 size_t arg2 ;
40314 int arg3 = (int) 0 ;
40315 PyObject * obj0 = 0 ;
40316 PyObject * obj1 = 0 ;
40317 PyObject * obj2 = 0 ;
40318 char *kwnames[] = {
40319 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40320 };
40321
40322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40324 if (SWIG_arg_fail(1)) SWIG_fail;
40325 {
40326 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40327 if (SWIG_arg_fail(2)) SWIG_fail;
40328 }
40329 if (obj2) {
40330 {
40331 arg3 = (int)(SWIG_As_int(obj2));
40332 if (SWIG_arg_fail(3)) SWIG_fail;
40333 }
40334 }
40335 {
40336 PyThreadState* __tstate = wxPyBeginAllowThreads();
40337 (arg1)->AddGrowableCol(arg2,arg3);
40338
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 Py_INCREF(Py_None); resultobj = Py_None;
40343 return resultobj;
40344 fail:
40345 return NULL;
40346 }
40347
40348
40349 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40350 PyObject *resultobj;
40351 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40352 size_t arg2 ;
40353 PyObject * obj0 = 0 ;
40354 PyObject * obj1 = 0 ;
40355 char *kwnames[] = {
40356 (char *) "self",(char *) "idx", NULL
40357 };
40358
40359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40361 if (SWIG_arg_fail(1)) SWIG_fail;
40362 {
40363 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40364 if (SWIG_arg_fail(2)) SWIG_fail;
40365 }
40366 {
40367 PyThreadState* __tstate = wxPyBeginAllowThreads();
40368 (arg1)->RemoveGrowableCol(arg2);
40369
40370 wxPyEndAllowThreads(__tstate);
40371 if (PyErr_Occurred()) SWIG_fail;
40372 }
40373 Py_INCREF(Py_None); resultobj = Py_None;
40374 return resultobj;
40375 fail:
40376 return NULL;
40377 }
40378
40379
40380 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40381 PyObject *resultobj;
40382 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40383 int arg2 ;
40384 PyObject * obj0 = 0 ;
40385 PyObject * obj1 = 0 ;
40386 char *kwnames[] = {
40387 (char *) "self",(char *) "direction", NULL
40388 };
40389
40390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40392 if (SWIG_arg_fail(1)) SWIG_fail;
40393 {
40394 arg2 = (int)(SWIG_As_int(obj1));
40395 if (SWIG_arg_fail(2)) SWIG_fail;
40396 }
40397 {
40398 PyThreadState* __tstate = wxPyBeginAllowThreads();
40399 (arg1)->SetFlexibleDirection(arg2);
40400
40401 wxPyEndAllowThreads(__tstate);
40402 if (PyErr_Occurred()) SWIG_fail;
40403 }
40404 Py_INCREF(Py_None); resultobj = Py_None;
40405 return resultobj;
40406 fail:
40407 return NULL;
40408 }
40409
40410
40411 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40412 PyObject *resultobj;
40413 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40414 int result;
40415 PyObject * obj0 = 0 ;
40416 char *kwnames[] = {
40417 (char *) "self", NULL
40418 };
40419
40420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40422 if (SWIG_arg_fail(1)) SWIG_fail;
40423 {
40424 PyThreadState* __tstate = wxPyBeginAllowThreads();
40425 result = (int)(arg1)->GetFlexibleDirection();
40426
40427 wxPyEndAllowThreads(__tstate);
40428 if (PyErr_Occurred()) SWIG_fail;
40429 }
40430 {
40431 resultobj = SWIG_From_int((int)(result));
40432 }
40433 return resultobj;
40434 fail:
40435 return NULL;
40436 }
40437
40438
40439 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40440 PyObject *resultobj;
40441 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40442 wxFlexSizerGrowMode arg2 ;
40443 PyObject * obj0 = 0 ;
40444 PyObject * obj1 = 0 ;
40445 char *kwnames[] = {
40446 (char *) "self",(char *) "mode", NULL
40447 };
40448
40449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40451 if (SWIG_arg_fail(1)) SWIG_fail;
40452 {
40453 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40454 if (SWIG_arg_fail(2)) SWIG_fail;
40455 }
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40459
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 Py_INCREF(Py_None); resultobj = Py_None;
40464 return resultobj;
40465 fail:
40466 return NULL;
40467 }
40468
40469
40470 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40471 PyObject *resultobj;
40472 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40473 wxFlexSizerGrowMode result;
40474 PyObject * obj0 = 0 ;
40475 char *kwnames[] = {
40476 (char *) "self", NULL
40477 };
40478
40479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40481 if (SWIG_arg_fail(1)) SWIG_fail;
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40485
40486 wxPyEndAllowThreads(__tstate);
40487 if (PyErr_Occurred()) SWIG_fail;
40488 }
40489 resultobj = SWIG_From_int((result));
40490 return resultobj;
40491 fail:
40492 return NULL;
40493 }
40494
40495
40496 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40497 PyObject *resultobj;
40498 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40499 wxArrayInt *result;
40500 PyObject * obj0 = 0 ;
40501 char *kwnames[] = {
40502 (char *) "self", NULL
40503 };
40504
40505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40507 if (SWIG_arg_fail(1)) SWIG_fail;
40508 {
40509 PyThreadState* __tstate = wxPyBeginAllowThreads();
40510 {
40511 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40512 result = (wxArrayInt *) &_result_ref;
40513 }
40514
40515 wxPyEndAllowThreads(__tstate);
40516 if (PyErr_Occurred()) SWIG_fail;
40517 }
40518 {
40519 resultobj = PyList_New(0);
40520 size_t idx;
40521 for (idx = 0; idx < result->GetCount(); idx += 1) {
40522 PyObject* val = PyInt_FromLong( result->Item(idx) );
40523 PyList_Append(resultobj, val);
40524 Py_DECREF(val);
40525 }
40526 }
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj;
40535 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40536 wxArrayInt *result;
40537 PyObject * obj0 = 0 ;
40538 char *kwnames[] = {
40539 (char *) "self", NULL
40540 };
40541
40542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40544 if (SWIG_arg_fail(1)) SWIG_fail;
40545 {
40546 PyThreadState* __tstate = wxPyBeginAllowThreads();
40547 {
40548 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40549 result = (wxArrayInt *) &_result_ref;
40550 }
40551
40552 wxPyEndAllowThreads(__tstate);
40553 if (PyErr_Occurred()) SWIG_fail;
40554 }
40555 {
40556 resultobj = PyList_New(0);
40557 size_t idx;
40558 for (idx = 0; idx < result->GetCount(); idx += 1) {
40559 PyObject* val = PyInt_FromLong( result->Item(idx) );
40560 PyList_Append(resultobj, val);
40561 Py_DECREF(val);
40562 }
40563 }
40564 return resultobj;
40565 fail:
40566 return NULL;
40567 }
40568
40569
40570 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40571 PyObject *obj;
40572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40573 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40574 Py_INCREF(obj);
40575 return Py_BuildValue((char *)"");
40576 }
40577 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40578 PyObject *resultobj;
40579 wxStdDialogButtonSizer *result;
40580 char *kwnames[] = {
40581 NULL
40582 };
40583
40584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40585 {
40586 PyThreadState* __tstate = wxPyBeginAllowThreads();
40587 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40588
40589 wxPyEndAllowThreads(__tstate);
40590 if (PyErr_Occurred()) SWIG_fail;
40591 }
40592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40593 return resultobj;
40594 fail:
40595 return NULL;
40596 }
40597
40598
40599 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40600 PyObject *resultobj;
40601 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40602 wxButton *arg2 = (wxButton *) 0 ;
40603 PyObject * obj0 = 0 ;
40604 PyObject * obj1 = 0 ;
40605 char *kwnames[] = {
40606 (char *) "self",(char *) "button", NULL
40607 };
40608
40609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40611 if (SWIG_arg_fail(1)) SWIG_fail;
40612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40613 if (SWIG_arg_fail(2)) SWIG_fail;
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 (arg1)->AddButton(arg2);
40617
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 Py_INCREF(Py_None); resultobj = Py_None;
40622 return resultobj;
40623 fail:
40624 return NULL;
40625 }
40626
40627
40628 static PyObject *_wrap_StdDialogButtonSizer_Finalise(PyObject *, PyObject *args, PyObject *kwargs) {
40629 PyObject *resultobj;
40630 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40631 PyObject * obj0 = 0 ;
40632 char *kwnames[] = {
40633 (char *) "self", NULL
40634 };
40635
40636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Finalise",kwnames,&obj0)) goto fail;
40637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40638 if (SWIG_arg_fail(1)) SWIG_fail;
40639 {
40640 PyThreadState* __tstate = wxPyBeginAllowThreads();
40641 (arg1)->Finalise();
40642
40643 wxPyEndAllowThreads(__tstate);
40644 if (PyErr_Occurred()) SWIG_fail;
40645 }
40646 Py_INCREF(Py_None); resultobj = Py_None;
40647 return resultobj;
40648 fail:
40649 return NULL;
40650 }
40651
40652
40653 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40654 PyObject *resultobj;
40655 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40656 wxButton *arg2 = (wxButton *) 0 ;
40657 PyObject * obj0 = 0 ;
40658 PyObject * obj1 = 0 ;
40659 char *kwnames[] = {
40660 (char *) "self",(char *) "button", NULL
40661 };
40662
40663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40665 if (SWIG_arg_fail(1)) SWIG_fail;
40666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40667 if (SWIG_arg_fail(2)) SWIG_fail;
40668 {
40669 PyThreadState* __tstate = wxPyBeginAllowThreads();
40670 (arg1)->SetAffirmativeButton(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 *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40683 PyObject *resultobj;
40684 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40685 wxButton *arg2 = (wxButton *) 0 ;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 char *kwnames[] = {
40689 (char *) "self",(char *) "button", NULL
40690 };
40691
40692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40694 if (SWIG_arg_fail(1)) SWIG_fail;
40695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40696 if (SWIG_arg_fail(2)) SWIG_fail;
40697 {
40698 PyThreadState* __tstate = wxPyBeginAllowThreads();
40699 (arg1)->SetNegativeButton(arg2);
40700
40701 wxPyEndAllowThreads(__tstate);
40702 if (PyErr_Occurred()) SWIG_fail;
40703 }
40704 Py_INCREF(Py_None); resultobj = Py_None;
40705 return resultobj;
40706 fail:
40707 return NULL;
40708 }
40709
40710
40711 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40712 PyObject *resultobj;
40713 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40714 wxButton *arg2 = (wxButton *) 0 ;
40715 PyObject * obj0 = 0 ;
40716 PyObject * obj1 = 0 ;
40717 char *kwnames[] = {
40718 (char *) "self",(char *) "button", NULL
40719 };
40720
40721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40723 if (SWIG_arg_fail(1)) SWIG_fail;
40724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40725 if (SWIG_arg_fail(2)) SWIG_fail;
40726 {
40727 PyThreadState* __tstate = wxPyBeginAllowThreads();
40728 (arg1)->SetCancelButton(arg2);
40729
40730 wxPyEndAllowThreads(__tstate);
40731 if (PyErr_Occurred()) SWIG_fail;
40732 }
40733 Py_INCREF(Py_None); resultobj = Py_None;
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj;
40742 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40743 wxButton *result;
40744 PyObject * obj0 = 0 ;
40745 char *kwnames[] = {
40746 (char *) "self", NULL
40747 };
40748
40749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40751 if (SWIG_arg_fail(1)) SWIG_fail;
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40755
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 {
40760 resultobj = wxPyMake_wxObject(result, 0);
40761 }
40762 return resultobj;
40763 fail:
40764 return NULL;
40765 }
40766
40767
40768 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40769 PyObject *resultobj;
40770 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40771 wxButton *result;
40772 PyObject * obj0 = 0 ;
40773 char *kwnames[] = {
40774 (char *) "self", NULL
40775 };
40776
40777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40779 if (SWIG_arg_fail(1)) SWIG_fail;
40780 {
40781 PyThreadState* __tstate = wxPyBeginAllowThreads();
40782 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40783
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 {
40788 resultobj = wxPyMake_wxObject(result, 0);
40789 }
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40797 PyObject *resultobj;
40798 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40799 wxButton *result;
40800 PyObject * obj0 = 0 ;
40801 char *kwnames[] = {
40802 (char *) "self", NULL
40803 };
40804
40805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40807 if (SWIG_arg_fail(1)) SWIG_fail;
40808 {
40809 PyThreadState* __tstate = wxPyBeginAllowThreads();
40810 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40811
40812 wxPyEndAllowThreads(__tstate);
40813 if (PyErr_Occurred()) SWIG_fail;
40814 }
40815 {
40816 resultobj = wxPyMake_wxObject(result, 0);
40817 }
40818 return resultobj;
40819 fail:
40820 return NULL;
40821 }
40822
40823
40824 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40825 PyObject *resultobj;
40826 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40827 wxButton *result;
40828 PyObject * obj0 = 0 ;
40829 char *kwnames[] = {
40830 (char *) "self", NULL
40831 };
40832
40833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40835 if (SWIG_arg_fail(1)) SWIG_fail;
40836 {
40837 PyThreadState* __tstate = wxPyBeginAllowThreads();
40838 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40839
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 {
40844 resultobj = wxPyMake_wxObject(result, 0);
40845 }
40846 return resultobj;
40847 fail:
40848 return NULL;
40849 }
40850
40851
40852 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40853 PyObject *resultobj;
40854 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40855 wxButton *result;
40856 PyObject * obj0 = 0 ;
40857 char *kwnames[] = {
40858 (char *) "self", NULL
40859 };
40860
40861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40863 if (SWIG_arg_fail(1)) SWIG_fail;
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40867
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 {
40872 resultobj = wxPyMake_wxObject(result, 0);
40873 }
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40881 PyObject *obj;
40882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40883 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40884 Py_INCREF(obj);
40885 return Py_BuildValue((char *)"");
40886 }
40887 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40888 PyObject *resultobj;
40889 int arg1 = (int) 0 ;
40890 int arg2 = (int) 0 ;
40891 wxGBPosition *result;
40892 PyObject * obj0 = 0 ;
40893 PyObject * obj1 = 0 ;
40894 char *kwnames[] = {
40895 (char *) "row",(char *) "col", NULL
40896 };
40897
40898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40899 if (obj0) {
40900 {
40901 arg1 = (int)(SWIG_As_int(obj0));
40902 if (SWIG_arg_fail(1)) SWIG_fail;
40903 }
40904 }
40905 if (obj1) {
40906 {
40907 arg2 = (int)(SWIG_As_int(obj1));
40908 if (SWIG_arg_fail(2)) SWIG_fail;
40909 }
40910 }
40911 {
40912 PyThreadState* __tstate = wxPyBeginAllowThreads();
40913 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40914
40915 wxPyEndAllowThreads(__tstate);
40916 if (PyErr_Occurred()) SWIG_fail;
40917 }
40918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40919 return resultobj;
40920 fail:
40921 return NULL;
40922 }
40923
40924
40925 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40926 PyObject *resultobj;
40927 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40928 int result;
40929 PyObject * obj0 = 0 ;
40930 char *kwnames[] = {
40931 (char *) "self", NULL
40932 };
40933
40934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40936 if (SWIG_arg_fail(1)) SWIG_fail;
40937 {
40938 PyThreadState* __tstate = wxPyBeginAllowThreads();
40939 result = (int)((wxGBPosition const *)arg1)->GetRow();
40940
40941 wxPyEndAllowThreads(__tstate);
40942 if (PyErr_Occurred()) SWIG_fail;
40943 }
40944 {
40945 resultobj = SWIG_From_int((int)(result));
40946 }
40947 return resultobj;
40948 fail:
40949 return NULL;
40950 }
40951
40952
40953 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40954 PyObject *resultobj;
40955 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40956 int result;
40957 PyObject * obj0 = 0 ;
40958 char *kwnames[] = {
40959 (char *) "self", NULL
40960 };
40961
40962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40964 if (SWIG_arg_fail(1)) SWIG_fail;
40965 {
40966 PyThreadState* __tstate = wxPyBeginAllowThreads();
40967 result = (int)((wxGBPosition const *)arg1)->GetCol();
40968
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 {
40973 resultobj = SWIG_From_int((int)(result));
40974 }
40975 return resultobj;
40976 fail:
40977 return NULL;
40978 }
40979
40980
40981 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40982 PyObject *resultobj;
40983 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40984 int arg2 ;
40985 PyObject * obj0 = 0 ;
40986 PyObject * obj1 = 0 ;
40987 char *kwnames[] = {
40988 (char *) "self",(char *) "row", NULL
40989 };
40990
40991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40993 if (SWIG_arg_fail(1)) SWIG_fail;
40994 {
40995 arg2 = (int)(SWIG_As_int(obj1));
40996 if (SWIG_arg_fail(2)) SWIG_fail;
40997 }
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 (arg1)->SetRow(arg2);
41001
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 Py_INCREF(Py_None); resultobj = Py_None;
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41013 PyObject *resultobj;
41014 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41015 int arg2 ;
41016 PyObject * obj0 = 0 ;
41017 PyObject * obj1 = 0 ;
41018 char *kwnames[] = {
41019 (char *) "self",(char *) "col", NULL
41020 };
41021
41022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41024 if (SWIG_arg_fail(1)) SWIG_fail;
41025 {
41026 arg2 = (int)(SWIG_As_int(obj1));
41027 if (SWIG_arg_fail(2)) SWIG_fail;
41028 }
41029 {
41030 PyThreadState* __tstate = wxPyBeginAllowThreads();
41031 (arg1)->SetCol(arg2);
41032
41033 wxPyEndAllowThreads(__tstate);
41034 if (PyErr_Occurred()) SWIG_fail;
41035 }
41036 Py_INCREF(Py_None); resultobj = Py_None;
41037 return resultobj;
41038 fail:
41039 return NULL;
41040 }
41041
41042
41043 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41044 PyObject *resultobj;
41045 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41046 wxGBPosition *arg2 = 0 ;
41047 bool result;
41048 wxGBPosition temp2 ;
41049 PyObject * obj0 = 0 ;
41050 PyObject * obj1 = 0 ;
41051 char *kwnames[] = {
41052 (char *) "self",(char *) "other", NULL
41053 };
41054
41055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41057 if (SWIG_arg_fail(1)) SWIG_fail;
41058 {
41059 arg2 = &temp2;
41060 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41061 }
41062 {
41063 PyThreadState* __tstate = wxPyBeginAllowThreads();
41064 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41065
41066 wxPyEndAllowThreads(__tstate);
41067 if (PyErr_Occurred()) SWIG_fail;
41068 }
41069 {
41070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41071 }
41072 return resultobj;
41073 fail:
41074 return NULL;
41075 }
41076
41077
41078 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41079 PyObject *resultobj;
41080 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41081 wxGBPosition *arg2 = 0 ;
41082 bool result;
41083 wxGBPosition temp2 ;
41084 PyObject * obj0 = 0 ;
41085 PyObject * obj1 = 0 ;
41086 char *kwnames[] = {
41087 (char *) "self",(char *) "other", NULL
41088 };
41089
41090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41092 if (SWIG_arg_fail(1)) SWIG_fail;
41093 {
41094 arg2 = &temp2;
41095 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41096 }
41097 {
41098 PyThreadState* __tstate = wxPyBeginAllowThreads();
41099 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41100
41101 wxPyEndAllowThreads(__tstate);
41102 if (PyErr_Occurred()) SWIG_fail;
41103 }
41104 {
41105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41106 }
41107 return resultobj;
41108 fail:
41109 return NULL;
41110 }
41111
41112
41113 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41114 PyObject *resultobj;
41115 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41116 int arg2 = (int) 0 ;
41117 int arg3 = (int) 0 ;
41118 PyObject * obj0 = 0 ;
41119 PyObject * obj1 = 0 ;
41120 PyObject * obj2 = 0 ;
41121 char *kwnames[] = {
41122 (char *) "self",(char *) "row",(char *) "col", NULL
41123 };
41124
41125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41127 if (SWIG_arg_fail(1)) SWIG_fail;
41128 if (obj1) {
41129 {
41130 arg2 = (int)(SWIG_As_int(obj1));
41131 if (SWIG_arg_fail(2)) SWIG_fail;
41132 }
41133 }
41134 if (obj2) {
41135 {
41136 arg3 = (int)(SWIG_As_int(obj2));
41137 if (SWIG_arg_fail(3)) SWIG_fail;
41138 }
41139 }
41140 {
41141 PyThreadState* __tstate = wxPyBeginAllowThreads();
41142 wxGBPosition_Set(arg1,arg2,arg3);
41143
41144 wxPyEndAllowThreads(__tstate);
41145 if (PyErr_Occurred()) SWIG_fail;
41146 }
41147 Py_INCREF(Py_None); resultobj = Py_None;
41148 return resultobj;
41149 fail:
41150 return NULL;
41151 }
41152
41153
41154 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41155 PyObject *resultobj;
41156 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41157 PyObject *result;
41158 PyObject * obj0 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 {
41167 PyThreadState* __tstate = wxPyBeginAllowThreads();
41168 result = (PyObject *)wxGBPosition_Get(arg1);
41169
41170 wxPyEndAllowThreads(__tstate);
41171 if (PyErr_Occurred()) SWIG_fail;
41172 }
41173 resultobj = result;
41174 return resultobj;
41175 fail:
41176 return NULL;
41177 }
41178
41179
41180 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41181 PyObject *obj;
41182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41183 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41184 Py_INCREF(obj);
41185 return Py_BuildValue((char *)"");
41186 }
41187 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41188 PyObject *resultobj;
41189 int arg1 = (int) 1 ;
41190 int arg2 = (int) 1 ;
41191 wxGBSpan *result;
41192 PyObject * obj0 = 0 ;
41193 PyObject * obj1 = 0 ;
41194 char *kwnames[] = {
41195 (char *) "rowspan",(char *) "colspan", NULL
41196 };
41197
41198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41199 if (obj0) {
41200 {
41201 arg1 = (int)(SWIG_As_int(obj0));
41202 if (SWIG_arg_fail(1)) SWIG_fail;
41203 }
41204 }
41205 if (obj1) {
41206 {
41207 arg2 = (int)(SWIG_As_int(obj1));
41208 if (SWIG_arg_fail(2)) SWIG_fail;
41209 }
41210 }
41211 {
41212 PyThreadState* __tstate = wxPyBeginAllowThreads();
41213 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41214
41215 wxPyEndAllowThreads(__tstate);
41216 if (PyErr_Occurred()) SWIG_fail;
41217 }
41218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41219 return resultobj;
41220 fail:
41221 return NULL;
41222 }
41223
41224
41225 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41226 PyObject *resultobj;
41227 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41228 int result;
41229 PyObject * obj0 = 0 ;
41230 char *kwnames[] = {
41231 (char *) "self", NULL
41232 };
41233
41234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41236 if (SWIG_arg_fail(1)) SWIG_fail;
41237 {
41238 PyThreadState* __tstate = wxPyBeginAllowThreads();
41239 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41240
41241 wxPyEndAllowThreads(__tstate);
41242 if (PyErr_Occurred()) SWIG_fail;
41243 }
41244 {
41245 resultobj = SWIG_From_int((int)(result));
41246 }
41247 return resultobj;
41248 fail:
41249 return NULL;
41250 }
41251
41252
41253 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41254 PyObject *resultobj;
41255 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41256 int result;
41257 PyObject * obj0 = 0 ;
41258 char *kwnames[] = {
41259 (char *) "self", NULL
41260 };
41261
41262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41264 if (SWIG_arg_fail(1)) SWIG_fail;
41265 {
41266 PyThreadState* __tstate = wxPyBeginAllowThreads();
41267 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41268
41269 wxPyEndAllowThreads(__tstate);
41270 if (PyErr_Occurred()) SWIG_fail;
41271 }
41272 {
41273 resultobj = SWIG_From_int((int)(result));
41274 }
41275 return resultobj;
41276 fail:
41277 return NULL;
41278 }
41279
41280
41281 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41282 PyObject *resultobj;
41283 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41284 int arg2 ;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 char *kwnames[] = {
41288 (char *) "self",(char *) "rowspan", NULL
41289 };
41290
41291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41293 if (SWIG_arg_fail(1)) SWIG_fail;
41294 {
41295 arg2 = (int)(SWIG_As_int(obj1));
41296 if (SWIG_arg_fail(2)) SWIG_fail;
41297 }
41298 {
41299 PyThreadState* __tstate = wxPyBeginAllowThreads();
41300 (arg1)->SetRowspan(arg2);
41301
41302 wxPyEndAllowThreads(__tstate);
41303 if (PyErr_Occurred()) SWIG_fail;
41304 }
41305 Py_INCREF(Py_None); resultobj = Py_None;
41306 return resultobj;
41307 fail:
41308 return NULL;
41309 }
41310
41311
41312 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41313 PyObject *resultobj;
41314 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41315 int arg2 ;
41316 PyObject * obj0 = 0 ;
41317 PyObject * obj1 = 0 ;
41318 char *kwnames[] = {
41319 (char *) "self",(char *) "colspan", NULL
41320 };
41321
41322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41324 if (SWIG_arg_fail(1)) SWIG_fail;
41325 {
41326 arg2 = (int)(SWIG_As_int(obj1));
41327 if (SWIG_arg_fail(2)) SWIG_fail;
41328 }
41329 {
41330 PyThreadState* __tstate = wxPyBeginAllowThreads();
41331 (arg1)->SetColspan(arg2);
41332
41333 wxPyEndAllowThreads(__tstate);
41334 if (PyErr_Occurred()) SWIG_fail;
41335 }
41336 Py_INCREF(Py_None); resultobj = Py_None;
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj;
41345 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41346 wxGBSpan *arg2 = 0 ;
41347 bool result;
41348 wxGBSpan temp2 ;
41349 PyObject * obj0 = 0 ;
41350 PyObject * obj1 = 0 ;
41351 char *kwnames[] = {
41352 (char *) "self",(char *) "other", NULL
41353 };
41354
41355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41357 if (SWIG_arg_fail(1)) SWIG_fail;
41358 {
41359 arg2 = &temp2;
41360 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41361 }
41362 {
41363 PyThreadState* __tstate = wxPyBeginAllowThreads();
41364 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41365
41366 wxPyEndAllowThreads(__tstate);
41367 if (PyErr_Occurred()) SWIG_fail;
41368 }
41369 {
41370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41371 }
41372 return resultobj;
41373 fail:
41374 return NULL;
41375 }
41376
41377
41378 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41379 PyObject *resultobj;
41380 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41381 wxGBSpan *arg2 = 0 ;
41382 bool result;
41383 wxGBSpan temp2 ;
41384 PyObject * obj0 = 0 ;
41385 PyObject * obj1 = 0 ;
41386 char *kwnames[] = {
41387 (char *) "self",(char *) "other", NULL
41388 };
41389
41390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41392 if (SWIG_arg_fail(1)) SWIG_fail;
41393 {
41394 arg2 = &temp2;
41395 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41396 }
41397 {
41398 PyThreadState* __tstate = wxPyBeginAllowThreads();
41399 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41400
41401 wxPyEndAllowThreads(__tstate);
41402 if (PyErr_Occurred()) SWIG_fail;
41403 }
41404 {
41405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41406 }
41407 return resultobj;
41408 fail:
41409 return NULL;
41410 }
41411
41412
41413 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41414 PyObject *resultobj;
41415 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41416 int arg2 = (int) 1 ;
41417 int arg3 = (int) 1 ;
41418 PyObject * obj0 = 0 ;
41419 PyObject * obj1 = 0 ;
41420 PyObject * obj2 = 0 ;
41421 char *kwnames[] = {
41422 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41423 };
41424
41425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41427 if (SWIG_arg_fail(1)) SWIG_fail;
41428 if (obj1) {
41429 {
41430 arg2 = (int)(SWIG_As_int(obj1));
41431 if (SWIG_arg_fail(2)) SWIG_fail;
41432 }
41433 }
41434 if (obj2) {
41435 {
41436 arg3 = (int)(SWIG_As_int(obj2));
41437 if (SWIG_arg_fail(3)) SWIG_fail;
41438 }
41439 }
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 wxGBSpan_Set(arg1,arg2,arg3);
41443
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 Py_INCREF(Py_None); resultobj = Py_None;
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41455 PyObject *resultobj;
41456 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41457 PyObject *result;
41458 PyObject * obj0 = 0 ;
41459 char *kwnames[] = {
41460 (char *) "self", NULL
41461 };
41462
41463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41465 if (SWIG_arg_fail(1)) SWIG_fail;
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (PyObject *)wxGBSpan_Get(arg1);
41469
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 resultobj = result;
41474 return resultobj;
41475 fail:
41476 return NULL;
41477 }
41478
41479
41480 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41481 PyObject *obj;
41482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41483 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41484 Py_INCREF(obj);
41485 return Py_BuildValue((char *)"");
41486 }
41487 static int _wrap_DefaultSpan_set(PyObject *) {
41488 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41489 return 1;
41490 }
41491
41492
41493 static PyObject *_wrap_DefaultSpan_get(void) {
41494 PyObject *pyobj;
41495
41496 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41497 return pyobj;
41498 }
41499
41500
41501 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41502 PyObject *resultobj;
41503 wxGBSizerItem *result;
41504 char *kwnames[] = {
41505 NULL
41506 };
41507
41508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41509 {
41510 PyThreadState* __tstate = wxPyBeginAllowThreads();
41511 result = (wxGBSizerItem *)new wxGBSizerItem();
41512
41513 wxPyEndAllowThreads(__tstate);
41514 if (PyErr_Occurred()) SWIG_fail;
41515 }
41516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41517 return resultobj;
41518 fail:
41519 return NULL;
41520 }
41521
41522
41523 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41524 PyObject *resultobj;
41525 wxWindow *arg1 = (wxWindow *) 0 ;
41526 wxGBPosition *arg2 = 0 ;
41527 wxGBSpan *arg3 = 0 ;
41528 int arg4 ;
41529 int arg5 ;
41530 PyObject *arg6 = (PyObject *) NULL ;
41531 wxGBSizerItem *result;
41532 wxGBPosition temp2 ;
41533 wxGBSpan temp3 ;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 PyObject * obj2 = 0 ;
41537 PyObject * obj3 = 0 ;
41538 PyObject * obj4 = 0 ;
41539 PyObject * obj5 = 0 ;
41540 char *kwnames[] = {
41541 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41542 };
41543
41544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41546 if (SWIG_arg_fail(1)) SWIG_fail;
41547 {
41548 arg2 = &temp2;
41549 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41550 }
41551 {
41552 arg3 = &temp3;
41553 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41554 }
41555 {
41556 arg4 = (int)(SWIG_As_int(obj3));
41557 if (SWIG_arg_fail(4)) SWIG_fail;
41558 }
41559 {
41560 arg5 = (int)(SWIG_As_int(obj4));
41561 if (SWIG_arg_fail(5)) SWIG_fail;
41562 }
41563 if (obj5) {
41564 arg6 = obj5;
41565 }
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41569
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41574 return resultobj;
41575 fail:
41576 return NULL;
41577 }
41578
41579
41580 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41581 PyObject *resultobj;
41582 wxSizer *arg1 = (wxSizer *) 0 ;
41583 wxGBPosition *arg2 = 0 ;
41584 wxGBSpan *arg3 = 0 ;
41585 int arg4 ;
41586 int arg5 ;
41587 PyObject *arg6 = (PyObject *) NULL ;
41588 wxGBSizerItem *result;
41589 wxGBPosition temp2 ;
41590 wxGBSpan temp3 ;
41591 PyObject * obj0 = 0 ;
41592 PyObject * obj1 = 0 ;
41593 PyObject * obj2 = 0 ;
41594 PyObject * obj3 = 0 ;
41595 PyObject * obj4 = 0 ;
41596 PyObject * obj5 = 0 ;
41597 char *kwnames[] = {
41598 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41599 };
41600
41601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41603 if (SWIG_arg_fail(1)) SWIG_fail;
41604 {
41605 arg2 = &temp2;
41606 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41607 }
41608 {
41609 arg3 = &temp3;
41610 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41611 }
41612 {
41613 arg4 = (int)(SWIG_As_int(obj3));
41614 if (SWIG_arg_fail(4)) SWIG_fail;
41615 }
41616 {
41617 arg5 = (int)(SWIG_As_int(obj4));
41618 if (SWIG_arg_fail(5)) SWIG_fail;
41619 }
41620 if (obj5) {
41621 arg6 = obj5;
41622 }
41623 {
41624 PyThreadState* __tstate = wxPyBeginAllowThreads();
41625 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41626
41627 wxPyEndAllowThreads(__tstate);
41628 if (PyErr_Occurred()) SWIG_fail;
41629 }
41630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41631 return resultobj;
41632 fail:
41633 return NULL;
41634 }
41635
41636
41637 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41638 PyObject *resultobj;
41639 int arg1 ;
41640 int arg2 ;
41641 wxGBPosition *arg3 = 0 ;
41642 wxGBSpan *arg4 = 0 ;
41643 int arg5 ;
41644 int arg6 ;
41645 PyObject *arg7 = (PyObject *) NULL ;
41646 wxGBSizerItem *result;
41647 wxGBPosition temp3 ;
41648 wxGBSpan temp4 ;
41649 PyObject * obj0 = 0 ;
41650 PyObject * obj1 = 0 ;
41651 PyObject * obj2 = 0 ;
41652 PyObject * obj3 = 0 ;
41653 PyObject * obj4 = 0 ;
41654 PyObject * obj5 = 0 ;
41655 PyObject * obj6 = 0 ;
41656 char *kwnames[] = {
41657 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41658 };
41659
41660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41661 {
41662 arg1 = (int)(SWIG_As_int(obj0));
41663 if (SWIG_arg_fail(1)) SWIG_fail;
41664 }
41665 {
41666 arg2 = (int)(SWIG_As_int(obj1));
41667 if (SWIG_arg_fail(2)) SWIG_fail;
41668 }
41669 {
41670 arg3 = &temp3;
41671 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41672 }
41673 {
41674 arg4 = &temp4;
41675 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41676 }
41677 {
41678 arg5 = (int)(SWIG_As_int(obj4));
41679 if (SWIG_arg_fail(5)) SWIG_fail;
41680 }
41681 {
41682 arg6 = (int)(SWIG_As_int(obj5));
41683 if (SWIG_arg_fail(6)) SWIG_fail;
41684 }
41685 if (obj6) {
41686 arg7 = obj6;
41687 }
41688 {
41689 PyThreadState* __tstate = wxPyBeginAllowThreads();
41690 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41691
41692 wxPyEndAllowThreads(__tstate);
41693 if (PyErr_Occurred()) SWIG_fail;
41694 }
41695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41696 return resultobj;
41697 fail:
41698 return NULL;
41699 }
41700
41701
41702 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41703 PyObject *resultobj;
41704 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41705 wxGBPosition result;
41706 PyObject * obj0 = 0 ;
41707 char *kwnames[] = {
41708 (char *) "self", NULL
41709 };
41710
41711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41713 if (SWIG_arg_fail(1)) SWIG_fail;
41714 {
41715 PyThreadState* __tstate = wxPyBeginAllowThreads();
41716 result = ((wxGBSizerItem const *)arg1)->GetPos();
41717
41718 wxPyEndAllowThreads(__tstate);
41719 if (PyErr_Occurred()) SWIG_fail;
41720 }
41721 {
41722 wxGBPosition * resultptr;
41723 resultptr = new wxGBPosition((wxGBPosition &)(result));
41724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41725 }
41726 return resultobj;
41727 fail:
41728 return NULL;
41729 }
41730
41731
41732 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41733 PyObject *resultobj;
41734 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41735 wxGBSpan result;
41736 PyObject * obj0 = 0 ;
41737 char *kwnames[] = {
41738 (char *) "self", NULL
41739 };
41740
41741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41743 if (SWIG_arg_fail(1)) SWIG_fail;
41744 {
41745 PyThreadState* __tstate = wxPyBeginAllowThreads();
41746 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41747
41748 wxPyEndAllowThreads(__tstate);
41749 if (PyErr_Occurred()) SWIG_fail;
41750 }
41751 {
41752 wxGBSpan * resultptr;
41753 resultptr = new wxGBSpan((wxGBSpan &)(result));
41754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41755 }
41756 return resultobj;
41757 fail:
41758 return NULL;
41759 }
41760
41761
41762 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41763 PyObject *resultobj;
41764 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41765 wxGBPosition *arg2 = 0 ;
41766 bool result;
41767 wxGBPosition temp2 ;
41768 PyObject * obj0 = 0 ;
41769 PyObject * obj1 = 0 ;
41770 char *kwnames[] = {
41771 (char *) "self",(char *) "pos", NULL
41772 };
41773
41774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41776 if (SWIG_arg_fail(1)) SWIG_fail;
41777 {
41778 arg2 = &temp2;
41779 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41780 }
41781 {
41782 PyThreadState* __tstate = wxPyBeginAllowThreads();
41783 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41784
41785 wxPyEndAllowThreads(__tstate);
41786 if (PyErr_Occurred()) SWIG_fail;
41787 }
41788 {
41789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41790 }
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj;
41799 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41800 wxGBSpan *arg2 = 0 ;
41801 bool result;
41802 wxGBSpan temp2 ;
41803 PyObject * obj0 = 0 ;
41804 PyObject * obj1 = 0 ;
41805 char *kwnames[] = {
41806 (char *) "self",(char *) "span", NULL
41807 };
41808
41809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41811 if (SWIG_arg_fail(1)) SWIG_fail;
41812 {
41813 arg2 = &temp2;
41814 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41815 }
41816 {
41817 PyThreadState* __tstate = wxPyBeginAllowThreads();
41818 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41819
41820 wxPyEndAllowThreads(__tstate);
41821 if (PyErr_Occurred()) SWIG_fail;
41822 }
41823 {
41824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41825 }
41826 return resultobj;
41827 fail:
41828 return NULL;
41829 }
41830
41831
41832 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41833 PyObject *resultobj;
41834 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41835 wxGBSizerItem *arg2 = 0 ;
41836 bool result;
41837 PyObject * obj0 = 0 ;
41838 PyObject * obj1 = 0 ;
41839 char *kwnames[] = {
41840 (char *) "self",(char *) "other", NULL
41841 };
41842
41843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41845 if (SWIG_arg_fail(1)) SWIG_fail;
41846 {
41847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41848 if (SWIG_arg_fail(2)) SWIG_fail;
41849 if (arg2 == NULL) {
41850 SWIG_null_ref("wxGBSizerItem");
41851 }
41852 if (SWIG_arg_fail(2)) SWIG_fail;
41853 }
41854 {
41855 PyThreadState* __tstate = wxPyBeginAllowThreads();
41856 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41857
41858 wxPyEndAllowThreads(__tstate);
41859 if (PyErr_Occurred()) SWIG_fail;
41860 }
41861 {
41862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41863 }
41864 return resultobj;
41865 fail:
41866 return NULL;
41867 }
41868
41869
41870 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41871 PyObject *resultobj;
41872 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41873 wxGBPosition *arg2 = 0 ;
41874 wxGBSpan *arg3 = 0 ;
41875 bool result;
41876 wxGBPosition temp2 ;
41877 wxGBSpan temp3 ;
41878 PyObject * obj0 = 0 ;
41879 PyObject * obj1 = 0 ;
41880 PyObject * obj2 = 0 ;
41881 char *kwnames[] = {
41882 (char *) "self",(char *) "pos",(char *) "span", NULL
41883 };
41884
41885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41887 if (SWIG_arg_fail(1)) SWIG_fail;
41888 {
41889 arg2 = &temp2;
41890 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41891 }
41892 {
41893 arg3 = &temp3;
41894 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41895 }
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 {
41904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41905 }
41906 return resultobj;
41907 fail:
41908 return NULL;
41909 }
41910
41911
41912 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41913 PyObject *resultobj;
41914 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41915 wxGBPosition result;
41916 PyObject * obj0 = 0 ;
41917 char *kwnames[] = {
41918 (char *) "self", NULL
41919 };
41920
41921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41923 if (SWIG_arg_fail(1)) SWIG_fail;
41924 {
41925 PyThreadState* __tstate = wxPyBeginAllowThreads();
41926 result = wxGBSizerItem_GetEndPos(arg1);
41927
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 {
41932 wxGBPosition * resultptr;
41933 resultptr = new wxGBPosition((wxGBPosition &)(result));
41934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41935 }
41936 return resultobj;
41937 fail:
41938 return NULL;
41939 }
41940
41941
41942 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41943 PyObject *resultobj;
41944 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41945 wxGridBagSizer *result;
41946 PyObject * obj0 = 0 ;
41947 char *kwnames[] = {
41948 (char *) "self", NULL
41949 };
41950
41951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41953 if (SWIG_arg_fail(1)) SWIG_fail;
41954 {
41955 PyThreadState* __tstate = wxPyBeginAllowThreads();
41956 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41957
41958 wxPyEndAllowThreads(__tstate);
41959 if (PyErr_Occurred()) SWIG_fail;
41960 }
41961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41962 return resultobj;
41963 fail:
41964 return NULL;
41965 }
41966
41967
41968 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41969 PyObject *resultobj;
41970 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41971 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41972 PyObject * obj0 = 0 ;
41973 PyObject * obj1 = 0 ;
41974 char *kwnames[] = {
41975 (char *) "self",(char *) "sizer", NULL
41976 };
41977
41978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41980 if (SWIG_arg_fail(1)) SWIG_fail;
41981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41982 if (SWIG_arg_fail(2)) SWIG_fail;
41983 {
41984 PyThreadState* __tstate = wxPyBeginAllowThreads();
41985 (arg1)->SetGBSizer(arg2);
41986
41987 wxPyEndAllowThreads(__tstate);
41988 if (PyErr_Occurred()) SWIG_fail;
41989 }
41990 Py_INCREF(Py_None); resultobj = Py_None;
41991 return resultobj;
41992 fail:
41993 return NULL;
41994 }
41995
41996
41997 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41998 PyObject *obj;
41999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42000 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42001 Py_INCREF(obj);
42002 return Py_BuildValue((char *)"");
42003 }
42004 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42005 PyObject *resultobj;
42006 int arg1 = (int) 0 ;
42007 int arg2 = (int) 0 ;
42008 wxGridBagSizer *result;
42009 PyObject * obj0 = 0 ;
42010 PyObject * obj1 = 0 ;
42011 char *kwnames[] = {
42012 (char *) "vgap",(char *) "hgap", NULL
42013 };
42014
42015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42016 if (obj0) {
42017 {
42018 arg1 = (int)(SWIG_As_int(obj0));
42019 if (SWIG_arg_fail(1)) SWIG_fail;
42020 }
42021 }
42022 if (obj1) {
42023 {
42024 arg2 = (int)(SWIG_As_int(obj1));
42025 if (SWIG_arg_fail(2)) SWIG_fail;
42026 }
42027 }
42028 {
42029 PyThreadState* __tstate = wxPyBeginAllowThreads();
42030 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42031
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42043 PyObject *resultobj;
42044 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42045 PyObject *arg2 = (PyObject *) 0 ;
42046 wxGBPosition *arg3 = 0 ;
42047 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42048 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42049 int arg5 = (int) 0 ;
42050 int arg6 = (int) 0 ;
42051 PyObject *arg7 = (PyObject *) NULL ;
42052 wxGBSizerItem *result;
42053 wxGBPosition temp3 ;
42054 wxGBSpan temp4 ;
42055 PyObject * obj0 = 0 ;
42056 PyObject * obj1 = 0 ;
42057 PyObject * obj2 = 0 ;
42058 PyObject * obj3 = 0 ;
42059 PyObject * obj4 = 0 ;
42060 PyObject * obj5 = 0 ;
42061 PyObject * obj6 = 0 ;
42062 char *kwnames[] = {
42063 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42064 };
42065
42066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42068 if (SWIG_arg_fail(1)) SWIG_fail;
42069 arg2 = obj1;
42070 {
42071 arg3 = &temp3;
42072 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42073 }
42074 if (obj3) {
42075 {
42076 arg4 = &temp4;
42077 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42078 }
42079 }
42080 if (obj4) {
42081 {
42082 arg5 = (int)(SWIG_As_int(obj4));
42083 if (SWIG_arg_fail(5)) SWIG_fail;
42084 }
42085 }
42086 if (obj5) {
42087 {
42088 arg6 = (int)(SWIG_As_int(obj5));
42089 if (SWIG_arg_fail(6)) SWIG_fail;
42090 }
42091 }
42092 if (obj6) {
42093 arg7 = obj6;
42094 }
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42098
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42103 return resultobj;
42104 fail:
42105 return NULL;
42106 }
42107
42108
42109 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42110 PyObject *resultobj;
42111 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42112 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42113 wxGBSizerItem *result;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 char *kwnames[] = {
42117 (char *) "self",(char *) "item", NULL
42118 };
42119
42120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42122 if (SWIG_arg_fail(1)) SWIG_fail;
42123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42124 if (SWIG_arg_fail(2)) SWIG_fail;
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42128
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj;
42141 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42142 int arg2 ;
42143 int arg3 ;
42144 wxSize result;
42145 PyObject * obj0 = 0 ;
42146 PyObject * obj1 = 0 ;
42147 PyObject * obj2 = 0 ;
42148 char *kwnames[] = {
42149 (char *) "self",(char *) "row",(char *) "col", NULL
42150 };
42151
42152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42154 if (SWIG_arg_fail(1)) SWIG_fail;
42155 {
42156 arg2 = (int)(SWIG_As_int(obj1));
42157 if (SWIG_arg_fail(2)) SWIG_fail;
42158 }
42159 {
42160 arg3 = (int)(SWIG_As_int(obj2));
42161 if (SWIG_arg_fail(3)) SWIG_fail;
42162 }
42163 {
42164 PyThreadState* __tstate = wxPyBeginAllowThreads();
42165 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42166
42167 wxPyEndAllowThreads(__tstate);
42168 if (PyErr_Occurred()) SWIG_fail;
42169 }
42170 {
42171 wxSize * resultptr;
42172 resultptr = new wxSize((wxSize &)(result));
42173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42174 }
42175 return resultobj;
42176 fail:
42177 return NULL;
42178 }
42179
42180
42181 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42182 PyObject *resultobj;
42183 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42184 wxSize result;
42185 PyObject * obj0 = 0 ;
42186 char *kwnames[] = {
42187 (char *) "self", NULL
42188 };
42189
42190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42192 if (SWIG_arg_fail(1)) SWIG_fail;
42193 {
42194 PyThreadState* __tstate = wxPyBeginAllowThreads();
42195 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42196
42197 wxPyEndAllowThreads(__tstate);
42198 if (PyErr_Occurred()) SWIG_fail;
42199 }
42200 {
42201 wxSize * resultptr;
42202 resultptr = new wxSize((wxSize &)(result));
42203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42204 }
42205 return resultobj;
42206 fail:
42207 return NULL;
42208 }
42209
42210
42211 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42212 PyObject *resultobj;
42213 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42214 wxSize *arg2 = 0 ;
42215 wxSize temp2 ;
42216 PyObject * obj0 = 0 ;
42217 PyObject * obj1 = 0 ;
42218 char *kwnames[] = {
42219 (char *) "self",(char *) "sz", NULL
42220 };
42221
42222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42224 if (SWIG_arg_fail(1)) SWIG_fail;
42225 {
42226 arg2 = &temp2;
42227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42228 }
42229 {
42230 PyThreadState* __tstate = wxPyBeginAllowThreads();
42231 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42232
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 Py_INCREF(Py_None); resultobj = Py_None;
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42244 PyObject *resultobj;
42245 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42246 wxWindow *arg2 = (wxWindow *) 0 ;
42247 wxGBPosition result;
42248 PyObject * obj0 = 0 ;
42249 PyObject * obj1 = 0 ;
42250
42251 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42253 if (SWIG_arg_fail(1)) SWIG_fail;
42254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42255 if (SWIG_arg_fail(2)) SWIG_fail;
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 result = (arg1)->GetItemPosition(arg2);
42259
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 {
42264 wxGBPosition * resultptr;
42265 resultptr = new wxGBPosition((wxGBPosition &)(result));
42266 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42267 }
42268 return resultobj;
42269 fail:
42270 return NULL;
42271 }
42272
42273
42274 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42275 PyObject *resultobj;
42276 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42277 wxSizer *arg2 = (wxSizer *) 0 ;
42278 wxGBPosition result;
42279 PyObject * obj0 = 0 ;
42280 PyObject * obj1 = 0 ;
42281
42282 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42284 if (SWIG_arg_fail(1)) SWIG_fail;
42285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42286 if (SWIG_arg_fail(2)) SWIG_fail;
42287 {
42288 PyThreadState* __tstate = wxPyBeginAllowThreads();
42289 result = (arg1)->GetItemPosition(arg2);
42290
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 {
42295 wxGBPosition * resultptr;
42296 resultptr = new wxGBPosition((wxGBPosition &)(result));
42297 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42298 }
42299 return resultobj;
42300 fail:
42301 return NULL;
42302 }
42303
42304
42305 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42306 PyObject *resultobj;
42307 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42308 size_t arg2 ;
42309 wxGBPosition result;
42310 PyObject * obj0 = 0 ;
42311 PyObject * obj1 = 0 ;
42312
42313 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42315 if (SWIG_arg_fail(1)) SWIG_fail;
42316 {
42317 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42318 if (SWIG_arg_fail(2)) SWIG_fail;
42319 }
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 result = (arg1)->GetItemPosition(arg2);
42323
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 {
42328 wxGBPosition * resultptr;
42329 resultptr = new wxGBPosition((wxGBPosition &)(result));
42330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42331 }
42332 return resultobj;
42333 fail:
42334 return NULL;
42335 }
42336
42337
42338 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42339 int argc;
42340 PyObject *argv[3];
42341 int ii;
42342
42343 argc = PyObject_Length(args);
42344 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42345 argv[ii] = PyTuple_GetItem(args,ii);
42346 }
42347 if (argc == 2) {
42348 int _v;
42349 {
42350 void *ptr;
42351 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42352 _v = 0;
42353 PyErr_Clear();
42354 } else {
42355 _v = 1;
42356 }
42357 }
42358 if (_v) {
42359 {
42360 void *ptr;
42361 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42362 _v = 0;
42363 PyErr_Clear();
42364 } else {
42365 _v = 1;
42366 }
42367 }
42368 if (_v) {
42369 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42370 }
42371 }
42372 }
42373 if (argc == 2) {
42374 int _v;
42375 {
42376 void *ptr;
42377 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42378 _v = 0;
42379 PyErr_Clear();
42380 } else {
42381 _v = 1;
42382 }
42383 }
42384 if (_v) {
42385 {
42386 void *ptr;
42387 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42388 _v = 0;
42389 PyErr_Clear();
42390 } else {
42391 _v = 1;
42392 }
42393 }
42394 if (_v) {
42395 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42396 }
42397 }
42398 }
42399 if (argc == 2) {
42400 int _v;
42401 {
42402 void *ptr;
42403 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42404 _v = 0;
42405 PyErr_Clear();
42406 } else {
42407 _v = 1;
42408 }
42409 }
42410 if (_v) {
42411 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42412 if (_v) {
42413 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42414 }
42415 }
42416 }
42417
42418 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42419 return NULL;
42420 }
42421
42422
42423 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42424 PyObject *resultobj;
42425 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42426 wxWindow *arg2 = (wxWindow *) 0 ;
42427 wxGBPosition *arg3 = 0 ;
42428 bool result;
42429 wxGBPosition temp3 ;
42430 PyObject * obj0 = 0 ;
42431 PyObject * obj1 = 0 ;
42432 PyObject * obj2 = 0 ;
42433
42434 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42436 if (SWIG_arg_fail(1)) SWIG_fail;
42437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42438 if (SWIG_arg_fail(2)) SWIG_fail;
42439 {
42440 arg3 = &temp3;
42441 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42442 }
42443 {
42444 PyThreadState* __tstate = wxPyBeginAllowThreads();
42445 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42446
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 {
42451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42452 }
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42460 PyObject *resultobj;
42461 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42462 wxSizer *arg2 = (wxSizer *) 0 ;
42463 wxGBPosition *arg3 = 0 ;
42464 bool result;
42465 wxGBPosition temp3 ;
42466 PyObject * obj0 = 0 ;
42467 PyObject * obj1 = 0 ;
42468 PyObject * obj2 = 0 ;
42469
42470 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42472 if (SWIG_arg_fail(1)) SWIG_fail;
42473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42474 if (SWIG_arg_fail(2)) SWIG_fail;
42475 {
42476 arg3 = &temp3;
42477 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42478 }
42479 {
42480 PyThreadState* __tstate = wxPyBeginAllowThreads();
42481 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42482
42483 wxPyEndAllowThreads(__tstate);
42484 if (PyErr_Occurred()) SWIG_fail;
42485 }
42486 {
42487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42488 }
42489 return resultobj;
42490 fail:
42491 return NULL;
42492 }
42493
42494
42495 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42496 PyObject *resultobj;
42497 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42498 size_t arg2 ;
42499 wxGBPosition *arg3 = 0 ;
42500 bool result;
42501 wxGBPosition temp3 ;
42502 PyObject * obj0 = 0 ;
42503 PyObject * obj1 = 0 ;
42504 PyObject * obj2 = 0 ;
42505
42506 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42508 if (SWIG_arg_fail(1)) SWIG_fail;
42509 {
42510 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42511 if (SWIG_arg_fail(2)) SWIG_fail;
42512 }
42513 {
42514 arg3 = &temp3;
42515 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42516 }
42517 {
42518 PyThreadState* __tstate = wxPyBeginAllowThreads();
42519 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42520
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 {
42525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42526 }
42527 return resultobj;
42528 fail:
42529 return NULL;
42530 }
42531
42532
42533 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42534 int argc;
42535 PyObject *argv[4];
42536 int ii;
42537
42538 argc = PyObject_Length(args);
42539 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42540 argv[ii] = PyTuple_GetItem(args,ii);
42541 }
42542 if (argc == 3) {
42543 int _v;
42544 {
42545 void *ptr;
42546 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42547 _v = 0;
42548 PyErr_Clear();
42549 } else {
42550 _v = 1;
42551 }
42552 }
42553 if (_v) {
42554 {
42555 void *ptr;
42556 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42557 _v = 0;
42558 PyErr_Clear();
42559 } else {
42560 _v = 1;
42561 }
42562 }
42563 if (_v) {
42564 {
42565 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42566 }
42567 if (_v) {
42568 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42569 }
42570 }
42571 }
42572 }
42573 if (argc == 3) {
42574 int _v;
42575 {
42576 void *ptr;
42577 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42578 _v = 0;
42579 PyErr_Clear();
42580 } else {
42581 _v = 1;
42582 }
42583 }
42584 if (_v) {
42585 {
42586 void *ptr;
42587 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42588 _v = 0;
42589 PyErr_Clear();
42590 } else {
42591 _v = 1;
42592 }
42593 }
42594 if (_v) {
42595 {
42596 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42597 }
42598 if (_v) {
42599 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42600 }
42601 }
42602 }
42603 }
42604 if (argc == 3) {
42605 int _v;
42606 {
42607 void *ptr;
42608 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42609 _v = 0;
42610 PyErr_Clear();
42611 } else {
42612 _v = 1;
42613 }
42614 }
42615 if (_v) {
42616 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42617 if (_v) {
42618 {
42619 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42620 }
42621 if (_v) {
42622 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42623 }
42624 }
42625 }
42626 }
42627
42628 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42629 return NULL;
42630 }
42631
42632
42633 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42634 PyObject *resultobj;
42635 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42636 wxWindow *arg2 = (wxWindow *) 0 ;
42637 wxGBSpan result;
42638 PyObject * obj0 = 0 ;
42639 PyObject * obj1 = 0 ;
42640
42641 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42643 if (SWIG_arg_fail(1)) SWIG_fail;
42644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42645 if (SWIG_arg_fail(2)) SWIG_fail;
42646 {
42647 PyThreadState* __tstate = wxPyBeginAllowThreads();
42648 result = (arg1)->GetItemSpan(arg2);
42649
42650 wxPyEndAllowThreads(__tstate);
42651 if (PyErr_Occurred()) SWIG_fail;
42652 }
42653 {
42654 wxGBSpan * resultptr;
42655 resultptr = new wxGBSpan((wxGBSpan &)(result));
42656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42657 }
42658 return resultobj;
42659 fail:
42660 return NULL;
42661 }
42662
42663
42664 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42665 PyObject *resultobj;
42666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42667 wxSizer *arg2 = (wxSizer *) 0 ;
42668 wxGBSpan result;
42669 PyObject * obj0 = 0 ;
42670 PyObject * obj1 = 0 ;
42671
42672 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42674 if (SWIG_arg_fail(1)) SWIG_fail;
42675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42676 if (SWIG_arg_fail(2)) SWIG_fail;
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 result = (arg1)->GetItemSpan(arg2);
42680
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 {
42685 wxGBSpan * resultptr;
42686 resultptr = new wxGBSpan((wxGBSpan &)(result));
42687 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42688 }
42689 return resultobj;
42690 fail:
42691 return NULL;
42692 }
42693
42694
42695 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42696 PyObject *resultobj;
42697 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42698 size_t arg2 ;
42699 wxGBSpan result;
42700 PyObject * obj0 = 0 ;
42701 PyObject * obj1 = 0 ;
42702
42703 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42705 if (SWIG_arg_fail(1)) SWIG_fail;
42706 {
42707 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42708 if (SWIG_arg_fail(2)) SWIG_fail;
42709 }
42710 {
42711 PyThreadState* __tstate = wxPyBeginAllowThreads();
42712 result = (arg1)->GetItemSpan(arg2);
42713
42714 wxPyEndAllowThreads(__tstate);
42715 if (PyErr_Occurred()) SWIG_fail;
42716 }
42717 {
42718 wxGBSpan * resultptr;
42719 resultptr = new wxGBSpan((wxGBSpan &)(result));
42720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42721 }
42722 return resultobj;
42723 fail:
42724 return NULL;
42725 }
42726
42727
42728 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42729 int argc;
42730 PyObject *argv[3];
42731 int ii;
42732
42733 argc = PyObject_Length(args);
42734 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42735 argv[ii] = PyTuple_GetItem(args,ii);
42736 }
42737 if (argc == 2) {
42738 int _v;
42739 {
42740 void *ptr;
42741 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42742 _v = 0;
42743 PyErr_Clear();
42744 } else {
42745 _v = 1;
42746 }
42747 }
42748 if (_v) {
42749 {
42750 void *ptr;
42751 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42752 _v = 0;
42753 PyErr_Clear();
42754 } else {
42755 _v = 1;
42756 }
42757 }
42758 if (_v) {
42759 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42760 }
42761 }
42762 }
42763 if (argc == 2) {
42764 int _v;
42765 {
42766 void *ptr;
42767 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42768 _v = 0;
42769 PyErr_Clear();
42770 } else {
42771 _v = 1;
42772 }
42773 }
42774 if (_v) {
42775 {
42776 void *ptr;
42777 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42778 _v = 0;
42779 PyErr_Clear();
42780 } else {
42781 _v = 1;
42782 }
42783 }
42784 if (_v) {
42785 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42786 }
42787 }
42788 }
42789 if (argc == 2) {
42790 int _v;
42791 {
42792 void *ptr;
42793 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42794 _v = 0;
42795 PyErr_Clear();
42796 } else {
42797 _v = 1;
42798 }
42799 }
42800 if (_v) {
42801 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42802 if (_v) {
42803 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42804 }
42805 }
42806 }
42807
42808 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42809 return NULL;
42810 }
42811
42812
42813 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42814 PyObject *resultobj;
42815 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42816 wxWindow *arg2 = (wxWindow *) 0 ;
42817 wxGBSpan *arg3 = 0 ;
42818 bool result;
42819 wxGBSpan temp3 ;
42820 PyObject * obj0 = 0 ;
42821 PyObject * obj1 = 0 ;
42822 PyObject * obj2 = 0 ;
42823
42824 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42826 if (SWIG_arg_fail(1)) SWIG_fail;
42827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42828 if (SWIG_arg_fail(2)) SWIG_fail;
42829 {
42830 arg3 = &temp3;
42831 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42832 }
42833 {
42834 PyThreadState* __tstate = wxPyBeginAllowThreads();
42835 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42836
42837 wxPyEndAllowThreads(__tstate);
42838 if (PyErr_Occurred()) SWIG_fail;
42839 }
42840 {
42841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42842 }
42843 return resultobj;
42844 fail:
42845 return NULL;
42846 }
42847
42848
42849 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42850 PyObject *resultobj;
42851 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42852 wxSizer *arg2 = (wxSizer *) 0 ;
42853 wxGBSpan *arg3 = 0 ;
42854 bool result;
42855 wxGBSpan temp3 ;
42856 PyObject * obj0 = 0 ;
42857 PyObject * obj1 = 0 ;
42858 PyObject * obj2 = 0 ;
42859
42860 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42862 if (SWIG_arg_fail(1)) SWIG_fail;
42863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42864 if (SWIG_arg_fail(2)) SWIG_fail;
42865 {
42866 arg3 = &temp3;
42867 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42868 }
42869 {
42870 PyThreadState* __tstate = wxPyBeginAllowThreads();
42871 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42872
42873 wxPyEndAllowThreads(__tstate);
42874 if (PyErr_Occurred()) SWIG_fail;
42875 }
42876 {
42877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42878 }
42879 return resultobj;
42880 fail:
42881 return NULL;
42882 }
42883
42884
42885 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42886 PyObject *resultobj;
42887 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42888 size_t arg2 ;
42889 wxGBSpan *arg3 = 0 ;
42890 bool result;
42891 wxGBSpan temp3 ;
42892 PyObject * obj0 = 0 ;
42893 PyObject * obj1 = 0 ;
42894 PyObject * obj2 = 0 ;
42895
42896 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42898 if (SWIG_arg_fail(1)) SWIG_fail;
42899 {
42900 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42901 if (SWIG_arg_fail(2)) SWIG_fail;
42902 }
42903 {
42904 arg3 = &temp3;
42905 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42906 }
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42910
42911 wxPyEndAllowThreads(__tstate);
42912 if (PyErr_Occurred()) SWIG_fail;
42913 }
42914 {
42915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42916 }
42917 return resultobj;
42918 fail:
42919 return NULL;
42920 }
42921
42922
42923 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42924 int argc;
42925 PyObject *argv[4];
42926 int ii;
42927
42928 argc = PyObject_Length(args);
42929 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42930 argv[ii] = PyTuple_GetItem(args,ii);
42931 }
42932 if (argc == 3) {
42933 int _v;
42934 {
42935 void *ptr;
42936 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42937 _v = 0;
42938 PyErr_Clear();
42939 } else {
42940 _v = 1;
42941 }
42942 }
42943 if (_v) {
42944 {
42945 void *ptr;
42946 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42947 _v = 0;
42948 PyErr_Clear();
42949 } else {
42950 _v = 1;
42951 }
42952 }
42953 if (_v) {
42954 {
42955 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42956 }
42957 if (_v) {
42958 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42959 }
42960 }
42961 }
42962 }
42963 if (argc == 3) {
42964 int _v;
42965 {
42966 void *ptr;
42967 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42968 _v = 0;
42969 PyErr_Clear();
42970 } else {
42971 _v = 1;
42972 }
42973 }
42974 if (_v) {
42975 {
42976 void *ptr;
42977 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42978 _v = 0;
42979 PyErr_Clear();
42980 } else {
42981 _v = 1;
42982 }
42983 }
42984 if (_v) {
42985 {
42986 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42987 }
42988 if (_v) {
42989 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42990 }
42991 }
42992 }
42993 }
42994 if (argc == 3) {
42995 int _v;
42996 {
42997 void *ptr;
42998 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42999 _v = 0;
43000 PyErr_Clear();
43001 } else {
43002 _v = 1;
43003 }
43004 }
43005 if (_v) {
43006 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43007 if (_v) {
43008 {
43009 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43010 }
43011 if (_v) {
43012 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43013 }
43014 }
43015 }
43016 }
43017
43018 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43019 return NULL;
43020 }
43021
43022
43023 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43024 PyObject *resultobj;
43025 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43026 wxWindow *arg2 = (wxWindow *) 0 ;
43027 wxGBSizerItem *result;
43028 PyObject * obj0 = 0 ;
43029 PyObject * obj1 = 0 ;
43030
43031 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43033 if (SWIG_arg_fail(1)) SWIG_fail;
43034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43035 if (SWIG_arg_fail(2)) SWIG_fail;
43036 {
43037 PyThreadState* __tstate = wxPyBeginAllowThreads();
43038 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43039
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43051 PyObject *resultobj;
43052 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43053 wxSizer *arg2 = (wxSizer *) 0 ;
43054 wxGBSizerItem *result;
43055 PyObject * obj0 = 0 ;
43056 PyObject * obj1 = 0 ;
43057
43058 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43060 if (SWIG_arg_fail(1)) SWIG_fail;
43061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43062 if (SWIG_arg_fail(2)) SWIG_fail;
43063 {
43064 PyThreadState* __tstate = wxPyBeginAllowThreads();
43065 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43066
43067 wxPyEndAllowThreads(__tstate);
43068 if (PyErr_Occurred()) SWIG_fail;
43069 }
43070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43071 return resultobj;
43072 fail:
43073 return NULL;
43074 }
43075
43076
43077 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43078 int argc;
43079 PyObject *argv[3];
43080 int ii;
43081
43082 argc = PyObject_Length(args);
43083 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43084 argv[ii] = PyTuple_GetItem(args,ii);
43085 }
43086 if (argc == 2) {
43087 int _v;
43088 {
43089 void *ptr;
43090 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43091 _v = 0;
43092 PyErr_Clear();
43093 } else {
43094 _v = 1;
43095 }
43096 }
43097 if (_v) {
43098 {
43099 void *ptr;
43100 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43101 _v = 0;
43102 PyErr_Clear();
43103 } else {
43104 _v = 1;
43105 }
43106 }
43107 if (_v) {
43108 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43109 }
43110 }
43111 }
43112 if (argc == 2) {
43113 int _v;
43114 {
43115 void *ptr;
43116 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43117 _v = 0;
43118 PyErr_Clear();
43119 } else {
43120 _v = 1;
43121 }
43122 }
43123 if (_v) {
43124 {
43125 void *ptr;
43126 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43127 _v = 0;
43128 PyErr_Clear();
43129 } else {
43130 _v = 1;
43131 }
43132 }
43133 if (_v) {
43134 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43135 }
43136 }
43137 }
43138
43139 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43140 return NULL;
43141 }
43142
43143
43144 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43145 PyObject *resultobj;
43146 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43147 wxGBPosition *arg2 = 0 ;
43148 wxGBSizerItem *result;
43149 wxGBPosition temp2 ;
43150 PyObject * obj0 = 0 ;
43151 PyObject * obj1 = 0 ;
43152 char *kwnames[] = {
43153 (char *) "self",(char *) "pos", NULL
43154 };
43155
43156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43158 if (SWIG_arg_fail(1)) SWIG_fail;
43159 {
43160 arg2 = &temp2;
43161 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43162 }
43163 {
43164 PyThreadState* __tstate = wxPyBeginAllowThreads();
43165 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43166
43167 wxPyEndAllowThreads(__tstate);
43168 if (PyErr_Occurred()) SWIG_fail;
43169 }
43170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43171 return resultobj;
43172 fail:
43173 return NULL;
43174 }
43175
43176
43177 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43178 PyObject *resultobj;
43179 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43180 wxPoint *arg2 = 0 ;
43181 wxGBSizerItem *result;
43182 wxPoint temp2 ;
43183 PyObject * obj0 = 0 ;
43184 PyObject * obj1 = 0 ;
43185 char *kwnames[] = {
43186 (char *) "self",(char *) "pt", NULL
43187 };
43188
43189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43191 if (SWIG_arg_fail(1)) SWIG_fail;
43192 {
43193 arg2 = &temp2;
43194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43195 }
43196 {
43197 PyThreadState* __tstate = wxPyBeginAllowThreads();
43198 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43199
43200 wxPyEndAllowThreads(__tstate);
43201 if (PyErr_Occurred()) SWIG_fail;
43202 }
43203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43204 return resultobj;
43205 fail:
43206 return NULL;
43207 }
43208
43209
43210 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43211 PyObject *resultobj;
43212 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43213 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43214 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43215 bool result;
43216 PyObject * obj0 = 0 ;
43217 PyObject * obj1 = 0 ;
43218 PyObject * obj2 = 0 ;
43219 char *kwnames[] = {
43220 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43221 };
43222
43223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43225 if (SWIG_arg_fail(1)) SWIG_fail;
43226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43227 if (SWIG_arg_fail(2)) SWIG_fail;
43228 if (obj2) {
43229 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43230 if (SWIG_arg_fail(3)) SWIG_fail;
43231 }
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43235
43236 wxPyEndAllowThreads(__tstate);
43237 if (PyErr_Occurred()) SWIG_fail;
43238 }
43239 {
43240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43241 }
43242 return resultobj;
43243 fail:
43244 return NULL;
43245 }
43246
43247
43248 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43249 PyObject *resultobj;
43250 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43251 wxGBPosition *arg2 = 0 ;
43252 wxGBSpan *arg3 = 0 ;
43253 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43254 bool result;
43255 wxGBPosition temp2 ;
43256 wxGBSpan temp3 ;
43257 PyObject * obj0 = 0 ;
43258 PyObject * obj1 = 0 ;
43259 PyObject * obj2 = 0 ;
43260 PyObject * obj3 = 0 ;
43261 char *kwnames[] = {
43262 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43263 };
43264
43265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43267 if (SWIG_arg_fail(1)) SWIG_fail;
43268 {
43269 arg2 = &temp2;
43270 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43271 }
43272 {
43273 arg3 = &temp3;
43274 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43275 }
43276 if (obj3) {
43277 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43278 if (SWIG_arg_fail(4)) SWIG_fail;
43279 }
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43283
43284 wxPyEndAllowThreads(__tstate);
43285 if (PyErr_Occurred()) SWIG_fail;
43286 }
43287 {
43288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43289 }
43290 return resultobj;
43291 fail:
43292 return NULL;
43293 }
43294
43295
43296 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43297 PyObject *obj;
43298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43299 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43300 Py_INCREF(obj);
43301 return Py_BuildValue((char *)"");
43302 }
43303 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43304 PyObject *resultobj;
43305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43306 wxRelationship arg2 ;
43307 wxWindow *arg3 = (wxWindow *) 0 ;
43308 wxEdge arg4 ;
43309 int arg5 = (int) 0 ;
43310 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43311 PyObject * obj0 = 0 ;
43312 PyObject * obj1 = 0 ;
43313 PyObject * obj2 = 0 ;
43314 PyObject * obj3 = 0 ;
43315 PyObject * obj4 = 0 ;
43316 PyObject * obj5 = 0 ;
43317 char *kwnames[] = {
43318 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43319 };
43320
43321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43323 if (SWIG_arg_fail(1)) SWIG_fail;
43324 {
43325 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43326 if (SWIG_arg_fail(2)) SWIG_fail;
43327 }
43328 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43329 if (SWIG_arg_fail(3)) SWIG_fail;
43330 {
43331 arg4 = (wxEdge)(SWIG_As_int(obj3));
43332 if (SWIG_arg_fail(4)) SWIG_fail;
43333 }
43334 if (obj4) {
43335 {
43336 arg5 = (int)(SWIG_As_int(obj4));
43337 if (SWIG_arg_fail(5)) SWIG_fail;
43338 }
43339 }
43340 if (obj5) {
43341 {
43342 arg6 = (int)(SWIG_As_int(obj5));
43343 if (SWIG_arg_fail(6)) SWIG_fail;
43344 }
43345 }
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43349
43350 wxPyEndAllowThreads(__tstate);
43351 if (PyErr_Occurred()) SWIG_fail;
43352 }
43353 Py_INCREF(Py_None); resultobj = Py_None;
43354 return resultobj;
43355 fail:
43356 return NULL;
43357 }
43358
43359
43360 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43361 PyObject *resultobj;
43362 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43363 wxWindow *arg2 = (wxWindow *) 0 ;
43364 int arg3 = (int) 0 ;
43365 PyObject * obj0 = 0 ;
43366 PyObject * obj1 = 0 ;
43367 PyObject * obj2 = 0 ;
43368 char *kwnames[] = {
43369 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43370 };
43371
43372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43374 if (SWIG_arg_fail(1)) SWIG_fail;
43375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43376 if (SWIG_arg_fail(2)) SWIG_fail;
43377 if (obj2) {
43378 {
43379 arg3 = (int)(SWIG_As_int(obj2));
43380 if (SWIG_arg_fail(3)) SWIG_fail;
43381 }
43382 }
43383 {
43384 PyThreadState* __tstate = wxPyBeginAllowThreads();
43385 (arg1)->LeftOf(arg2,arg3);
43386
43387 wxPyEndAllowThreads(__tstate);
43388 if (PyErr_Occurred()) SWIG_fail;
43389 }
43390 Py_INCREF(Py_None); resultobj = Py_None;
43391 return resultobj;
43392 fail:
43393 return NULL;
43394 }
43395
43396
43397 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43398 PyObject *resultobj;
43399 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43400 wxWindow *arg2 = (wxWindow *) 0 ;
43401 int arg3 = (int) 0 ;
43402 PyObject * obj0 = 0 ;
43403 PyObject * obj1 = 0 ;
43404 PyObject * obj2 = 0 ;
43405 char *kwnames[] = {
43406 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43407 };
43408
43409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43411 if (SWIG_arg_fail(1)) SWIG_fail;
43412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43413 if (SWIG_arg_fail(2)) SWIG_fail;
43414 if (obj2) {
43415 {
43416 arg3 = (int)(SWIG_As_int(obj2));
43417 if (SWIG_arg_fail(3)) SWIG_fail;
43418 }
43419 }
43420 {
43421 PyThreadState* __tstate = wxPyBeginAllowThreads();
43422 (arg1)->RightOf(arg2,arg3);
43423
43424 wxPyEndAllowThreads(__tstate);
43425 if (PyErr_Occurred()) SWIG_fail;
43426 }
43427 Py_INCREF(Py_None); resultobj = Py_None;
43428 return resultobj;
43429 fail:
43430 return NULL;
43431 }
43432
43433
43434 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43435 PyObject *resultobj;
43436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43437 wxWindow *arg2 = (wxWindow *) 0 ;
43438 int arg3 = (int) 0 ;
43439 PyObject * obj0 = 0 ;
43440 PyObject * obj1 = 0 ;
43441 PyObject * obj2 = 0 ;
43442 char *kwnames[] = {
43443 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43444 };
43445
43446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43448 if (SWIG_arg_fail(1)) SWIG_fail;
43449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43450 if (SWIG_arg_fail(2)) SWIG_fail;
43451 if (obj2) {
43452 {
43453 arg3 = (int)(SWIG_As_int(obj2));
43454 if (SWIG_arg_fail(3)) SWIG_fail;
43455 }
43456 }
43457 {
43458 PyThreadState* __tstate = wxPyBeginAllowThreads();
43459 (arg1)->Above(arg2,arg3);
43460
43461 wxPyEndAllowThreads(__tstate);
43462 if (PyErr_Occurred()) SWIG_fail;
43463 }
43464 Py_INCREF(Py_None); resultobj = Py_None;
43465 return resultobj;
43466 fail:
43467 return NULL;
43468 }
43469
43470
43471 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43472 PyObject *resultobj;
43473 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43474 wxWindow *arg2 = (wxWindow *) 0 ;
43475 int arg3 = (int) 0 ;
43476 PyObject * obj0 = 0 ;
43477 PyObject * obj1 = 0 ;
43478 PyObject * obj2 = 0 ;
43479 char *kwnames[] = {
43480 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43481 };
43482
43483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43485 if (SWIG_arg_fail(1)) SWIG_fail;
43486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43487 if (SWIG_arg_fail(2)) SWIG_fail;
43488 if (obj2) {
43489 {
43490 arg3 = (int)(SWIG_As_int(obj2));
43491 if (SWIG_arg_fail(3)) SWIG_fail;
43492 }
43493 }
43494 {
43495 PyThreadState* __tstate = wxPyBeginAllowThreads();
43496 (arg1)->Below(arg2,arg3);
43497
43498 wxPyEndAllowThreads(__tstate);
43499 if (PyErr_Occurred()) SWIG_fail;
43500 }
43501 Py_INCREF(Py_None); resultobj = Py_None;
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj;
43510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43511 wxWindow *arg2 = (wxWindow *) 0 ;
43512 wxEdge arg3 ;
43513 int arg4 = (int) 0 ;
43514 PyObject * obj0 = 0 ;
43515 PyObject * obj1 = 0 ;
43516 PyObject * obj2 = 0 ;
43517 PyObject * obj3 = 0 ;
43518 char *kwnames[] = {
43519 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43520 };
43521
43522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43524 if (SWIG_arg_fail(1)) SWIG_fail;
43525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43526 if (SWIG_arg_fail(2)) SWIG_fail;
43527 {
43528 arg3 = (wxEdge)(SWIG_As_int(obj2));
43529 if (SWIG_arg_fail(3)) SWIG_fail;
43530 }
43531 if (obj3) {
43532 {
43533 arg4 = (int)(SWIG_As_int(obj3));
43534 if (SWIG_arg_fail(4)) SWIG_fail;
43535 }
43536 }
43537 {
43538 PyThreadState* __tstate = wxPyBeginAllowThreads();
43539 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43540
43541 wxPyEndAllowThreads(__tstate);
43542 if (PyErr_Occurred()) SWIG_fail;
43543 }
43544 Py_INCREF(Py_None); resultobj = Py_None;
43545 return resultobj;
43546 fail:
43547 return NULL;
43548 }
43549
43550
43551 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43552 PyObject *resultobj;
43553 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43554 wxWindow *arg2 = (wxWindow *) 0 ;
43555 wxEdge arg3 ;
43556 int arg4 ;
43557 PyObject * obj0 = 0 ;
43558 PyObject * obj1 = 0 ;
43559 PyObject * obj2 = 0 ;
43560 PyObject * obj3 = 0 ;
43561 char *kwnames[] = {
43562 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43563 };
43564
43565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43567 if (SWIG_arg_fail(1)) SWIG_fail;
43568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43569 if (SWIG_arg_fail(2)) SWIG_fail;
43570 {
43571 arg3 = (wxEdge)(SWIG_As_int(obj2));
43572 if (SWIG_arg_fail(3)) SWIG_fail;
43573 }
43574 {
43575 arg4 = (int)(SWIG_As_int(obj3));
43576 if (SWIG_arg_fail(4)) SWIG_fail;
43577 }
43578 {
43579 PyThreadState* __tstate = wxPyBeginAllowThreads();
43580 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43581
43582 wxPyEndAllowThreads(__tstate);
43583 if (PyErr_Occurred()) SWIG_fail;
43584 }
43585 Py_INCREF(Py_None); resultobj = Py_None;
43586 return resultobj;
43587 fail:
43588 return NULL;
43589 }
43590
43591
43592 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43593 PyObject *resultobj;
43594 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43595 int arg2 ;
43596 PyObject * obj0 = 0 ;
43597 PyObject * obj1 = 0 ;
43598 char *kwnames[] = {
43599 (char *) "self",(char *) "val", NULL
43600 };
43601
43602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43604 if (SWIG_arg_fail(1)) SWIG_fail;
43605 {
43606 arg2 = (int)(SWIG_As_int(obj1));
43607 if (SWIG_arg_fail(2)) SWIG_fail;
43608 }
43609 {
43610 PyThreadState* __tstate = wxPyBeginAllowThreads();
43611 (arg1)->Absolute(arg2);
43612
43613 wxPyEndAllowThreads(__tstate);
43614 if (PyErr_Occurred()) SWIG_fail;
43615 }
43616 Py_INCREF(Py_None); resultobj = Py_None;
43617 return resultobj;
43618 fail:
43619 return NULL;
43620 }
43621
43622
43623 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43624 PyObject *resultobj;
43625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43626 PyObject * obj0 = 0 ;
43627 char *kwnames[] = {
43628 (char *) "self", NULL
43629 };
43630
43631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43633 if (SWIG_arg_fail(1)) SWIG_fail;
43634 {
43635 PyThreadState* __tstate = wxPyBeginAllowThreads();
43636 (arg1)->Unconstrained();
43637
43638 wxPyEndAllowThreads(__tstate);
43639 if (PyErr_Occurred()) SWIG_fail;
43640 }
43641 Py_INCREF(Py_None); resultobj = Py_None;
43642 return resultobj;
43643 fail:
43644 return NULL;
43645 }
43646
43647
43648 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43649 PyObject *resultobj;
43650 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43651 PyObject * obj0 = 0 ;
43652 char *kwnames[] = {
43653 (char *) "self", NULL
43654 };
43655
43656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43658 if (SWIG_arg_fail(1)) SWIG_fail;
43659 {
43660 PyThreadState* __tstate = wxPyBeginAllowThreads();
43661 (arg1)->AsIs();
43662
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 Py_INCREF(Py_None); resultobj = Py_None;
43667 return resultobj;
43668 fail:
43669 return NULL;
43670 }
43671
43672
43673 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43674 PyObject *resultobj;
43675 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43676 wxWindow *result;
43677 PyObject * obj0 = 0 ;
43678 char *kwnames[] = {
43679 (char *) "self", NULL
43680 };
43681
43682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43684 if (SWIG_arg_fail(1)) SWIG_fail;
43685 {
43686 PyThreadState* __tstate = wxPyBeginAllowThreads();
43687 result = (wxWindow *)(arg1)->GetOtherWindow();
43688
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 resultobj = wxPyMake_wxObject(result, 0);
43694 }
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43702 PyObject *resultobj;
43703 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43704 wxEdge result;
43705 PyObject * obj0 = 0 ;
43706 char *kwnames[] = {
43707 (char *) "self", NULL
43708 };
43709
43710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43712 if (SWIG_arg_fail(1)) SWIG_fail;
43713 {
43714 PyThreadState* __tstate = wxPyBeginAllowThreads();
43715 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43716
43717 wxPyEndAllowThreads(__tstate);
43718 if (PyErr_Occurred()) SWIG_fail;
43719 }
43720 resultobj = SWIG_From_int((result));
43721 return resultobj;
43722 fail:
43723 return NULL;
43724 }
43725
43726
43727 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43728 PyObject *resultobj;
43729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43730 wxEdge arg2 ;
43731 PyObject * obj0 = 0 ;
43732 PyObject * obj1 = 0 ;
43733 char *kwnames[] = {
43734 (char *) "self",(char *) "which", NULL
43735 };
43736
43737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43739 if (SWIG_arg_fail(1)) SWIG_fail;
43740 {
43741 arg2 = (wxEdge)(SWIG_As_int(obj1));
43742 if (SWIG_arg_fail(2)) SWIG_fail;
43743 }
43744 {
43745 PyThreadState* __tstate = wxPyBeginAllowThreads();
43746 (arg1)->SetEdge((wxEdge )arg2);
43747
43748 wxPyEndAllowThreads(__tstate);
43749 if (PyErr_Occurred()) SWIG_fail;
43750 }
43751 Py_INCREF(Py_None); resultobj = Py_None;
43752 return resultobj;
43753 fail:
43754 return NULL;
43755 }
43756
43757
43758 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43759 PyObject *resultobj;
43760 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43761 int arg2 ;
43762 PyObject * obj0 = 0 ;
43763 PyObject * obj1 = 0 ;
43764 char *kwnames[] = {
43765 (char *) "self",(char *) "v", NULL
43766 };
43767
43768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43770 if (SWIG_arg_fail(1)) SWIG_fail;
43771 {
43772 arg2 = (int)(SWIG_As_int(obj1));
43773 if (SWIG_arg_fail(2)) SWIG_fail;
43774 }
43775 {
43776 PyThreadState* __tstate = wxPyBeginAllowThreads();
43777 (arg1)->SetValue(arg2);
43778
43779 wxPyEndAllowThreads(__tstate);
43780 if (PyErr_Occurred()) SWIG_fail;
43781 }
43782 Py_INCREF(Py_None); resultobj = Py_None;
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43790 PyObject *resultobj;
43791 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43792 int result;
43793 PyObject * obj0 = 0 ;
43794 char *kwnames[] = {
43795 (char *) "self", NULL
43796 };
43797
43798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43800 if (SWIG_arg_fail(1)) SWIG_fail;
43801 {
43802 PyThreadState* __tstate = wxPyBeginAllowThreads();
43803 result = (int)(arg1)->GetMargin();
43804
43805 wxPyEndAllowThreads(__tstate);
43806 if (PyErr_Occurred()) SWIG_fail;
43807 }
43808 {
43809 resultobj = SWIG_From_int((int)(result));
43810 }
43811 return resultobj;
43812 fail:
43813 return NULL;
43814 }
43815
43816
43817 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43818 PyObject *resultobj;
43819 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43820 int arg2 ;
43821 PyObject * obj0 = 0 ;
43822 PyObject * obj1 = 0 ;
43823 char *kwnames[] = {
43824 (char *) "self",(char *) "m", NULL
43825 };
43826
43827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43829 if (SWIG_arg_fail(1)) SWIG_fail;
43830 {
43831 arg2 = (int)(SWIG_As_int(obj1));
43832 if (SWIG_arg_fail(2)) SWIG_fail;
43833 }
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->SetMargin(arg2);
43837
43838 wxPyEndAllowThreads(__tstate);
43839 if (PyErr_Occurred()) SWIG_fail;
43840 }
43841 Py_INCREF(Py_None); resultobj = Py_None;
43842 return resultobj;
43843 fail:
43844 return NULL;
43845 }
43846
43847
43848 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43849 PyObject *resultobj;
43850 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43851 int result;
43852 PyObject * obj0 = 0 ;
43853 char *kwnames[] = {
43854 (char *) "self", NULL
43855 };
43856
43857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43859 if (SWIG_arg_fail(1)) SWIG_fail;
43860 {
43861 PyThreadState* __tstate = wxPyBeginAllowThreads();
43862 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43863
43864 wxPyEndAllowThreads(__tstate);
43865 if (PyErr_Occurred()) SWIG_fail;
43866 }
43867 {
43868 resultobj = SWIG_From_int((int)(result));
43869 }
43870 return resultobj;
43871 fail:
43872 return NULL;
43873 }
43874
43875
43876 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43877 PyObject *resultobj;
43878 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43879 int result;
43880 PyObject * obj0 = 0 ;
43881 char *kwnames[] = {
43882 (char *) "self", NULL
43883 };
43884
43885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43887 if (SWIG_arg_fail(1)) SWIG_fail;
43888 {
43889 PyThreadState* __tstate = wxPyBeginAllowThreads();
43890 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43891
43892 wxPyEndAllowThreads(__tstate);
43893 if (PyErr_Occurred()) SWIG_fail;
43894 }
43895 {
43896 resultobj = SWIG_From_int((int)(result));
43897 }
43898 return resultobj;
43899 fail:
43900 return NULL;
43901 }
43902
43903
43904 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43905 PyObject *resultobj;
43906 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43907 int result;
43908 PyObject * obj0 = 0 ;
43909 char *kwnames[] = {
43910 (char *) "self", NULL
43911 };
43912
43913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43915 if (SWIG_arg_fail(1)) SWIG_fail;
43916 {
43917 PyThreadState* __tstate = wxPyBeginAllowThreads();
43918 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43919
43920 wxPyEndAllowThreads(__tstate);
43921 if (PyErr_Occurred()) SWIG_fail;
43922 }
43923 {
43924 resultobj = SWIG_From_int((int)(result));
43925 }
43926 return resultobj;
43927 fail:
43928 return NULL;
43929 }
43930
43931
43932 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43933 PyObject *resultobj;
43934 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43935 bool result;
43936 PyObject * obj0 = 0 ;
43937 char *kwnames[] = {
43938 (char *) "self", NULL
43939 };
43940
43941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43943 if (SWIG_arg_fail(1)) SWIG_fail;
43944 {
43945 PyThreadState* __tstate = wxPyBeginAllowThreads();
43946 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43947
43948 wxPyEndAllowThreads(__tstate);
43949 if (PyErr_Occurred()) SWIG_fail;
43950 }
43951 {
43952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43953 }
43954 return resultobj;
43955 fail:
43956 return NULL;
43957 }
43958
43959
43960 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43961 PyObject *resultobj;
43962 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43963 bool arg2 ;
43964 PyObject * obj0 = 0 ;
43965 PyObject * obj1 = 0 ;
43966 char *kwnames[] = {
43967 (char *) "self",(char *) "d", NULL
43968 };
43969
43970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43972 if (SWIG_arg_fail(1)) SWIG_fail;
43973 {
43974 arg2 = (bool)(SWIG_As_bool(obj1));
43975 if (SWIG_arg_fail(2)) SWIG_fail;
43976 }
43977 {
43978 PyThreadState* __tstate = wxPyBeginAllowThreads();
43979 (arg1)->SetDone(arg2);
43980
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 Py_INCREF(Py_None); resultobj = Py_None;
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43992 PyObject *resultobj;
43993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43994 wxRelationship result;
43995 PyObject * obj0 = 0 ;
43996 char *kwnames[] = {
43997 (char *) "self", NULL
43998 };
43999
44000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44002 if (SWIG_arg_fail(1)) SWIG_fail;
44003 {
44004 PyThreadState* __tstate = wxPyBeginAllowThreads();
44005 result = (wxRelationship)(arg1)->GetRelationship();
44006
44007 wxPyEndAllowThreads(__tstate);
44008 if (PyErr_Occurred()) SWIG_fail;
44009 }
44010 resultobj = SWIG_From_int((result));
44011 return resultobj;
44012 fail:
44013 return NULL;
44014 }
44015
44016
44017 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44018 PyObject *resultobj;
44019 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44020 wxRelationship arg2 ;
44021 PyObject * obj0 = 0 ;
44022 PyObject * obj1 = 0 ;
44023 char *kwnames[] = {
44024 (char *) "self",(char *) "r", NULL
44025 };
44026
44027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44029 if (SWIG_arg_fail(1)) SWIG_fail;
44030 {
44031 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44032 if (SWIG_arg_fail(2)) SWIG_fail;
44033 }
44034 {
44035 PyThreadState* __tstate = wxPyBeginAllowThreads();
44036 (arg1)->SetRelationship((wxRelationship )arg2);
44037
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 Py_INCREF(Py_None); resultobj = Py_None;
44042 return resultobj;
44043 fail:
44044 return NULL;
44045 }
44046
44047
44048 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44049 PyObject *resultobj;
44050 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44051 wxWindow *arg2 = (wxWindow *) 0 ;
44052 bool result;
44053 PyObject * obj0 = 0 ;
44054 PyObject * obj1 = 0 ;
44055 char *kwnames[] = {
44056 (char *) "self",(char *) "otherW", NULL
44057 };
44058
44059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44061 if (SWIG_arg_fail(1)) SWIG_fail;
44062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44063 if (SWIG_arg_fail(2)) SWIG_fail;
44064 {
44065 PyThreadState* __tstate = wxPyBeginAllowThreads();
44066 result = (bool)(arg1)->ResetIfWin(arg2);
44067
44068 wxPyEndAllowThreads(__tstate);
44069 if (PyErr_Occurred()) SWIG_fail;
44070 }
44071 {
44072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44073 }
44074 return resultobj;
44075 fail:
44076 return NULL;
44077 }
44078
44079
44080 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44081 PyObject *resultobj;
44082 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44083 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44084 wxWindow *arg3 = (wxWindow *) 0 ;
44085 bool result;
44086 PyObject * obj0 = 0 ;
44087 PyObject * obj1 = 0 ;
44088 PyObject * obj2 = 0 ;
44089 char *kwnames[] = {
44090 (char *) "self",(char *) "constraints",(char *) "win", NULL
44091 };
44092
44093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44095 if (SWIG_arg_fail(1)) SWIG_fail;
44096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44097 if (SWIG_arg_fail(2)) SWIG_fail;
44098 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44099 if (SWIG_arg_fail(3)) SWIG_fail;
44100 {
44101 PyThreadState* __tstate = wxPyBeginAllowThreads();
44102 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44103
44104 wxPyEndAllowThreads(__tstate);
44105 if (PyErr_Occurred()) SWIG_fail;
44106 }
44107 {
44108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44109 }
44110 return resultobj;
44111 fail:
44112 return NULL;
44113 }
44114
44115
44116 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44117 PyObject *resultobj;
44118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44119 wxEdge arg2 ;
44120 wxWindow *arg3 = (wxWindow *) 0 ;
44121 wxWindow *arg4 = (wxWindow *) 0 ;
44122 int result;
44123 PyObject * obj0 = 0 ;
44124 PyObject * obj1 = 0 ;
44125 PyObject * obj2 = 0 ;
44126 PyObject * obj3 = 0 ;
44127 char *kwnames[] = {
44128 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44129 };
44130
44131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44133 if (SWIG_arg_fail(1)) SWIG_fail;
44134 {
44135 arg2 = (wxEdge)(SWIG_As_int(obj1));
44136 if (SWIG_arg_fail(2)) SWIG_fail;
44137 }
44138 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44139 if (SWIG_arg_fail(3)) SWIG_fail;
44140 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44141 if (SWIG_arg_fail(4)) SWIG_fail;
44142 {
44143 PyThreadState* __tstate = wxPyBeginAllowThreads();
44144 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44145
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 {
44150 resultobj = SWIG_From_int((int)(result));
44151 }
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44159 PyObject *obj;
44160 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44161 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44162 Py_INCREF(obj);
44163 return Py_BuildValue((char *)"");
44164 }
44165 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44166 PyObject *resultobj;
44167 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44168 wxIndividualLayoutConstraint *result;
44169 PyObject * obj0 = 0 ;
44170 char *kwnames[] = {
44171 (char *) "self", NULL
44172 };
44173
44174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44176 if (SWIG_arg_fail(1)) SWIG_fail;
44177 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44178
44179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44180 return resultobj;
44181 fail:
44182 return NULL;
44183 }
44184
44185
44186 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44187 PyObject *resultobj;
44188 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44189 wxIndividualLayoutConstraint *result;
44190 PyObject * obj0 = 0 ;
44191 char *kwnames[] = {
44192 (char *) "self", NULL
44193 };
44194
44195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44197 if (SWIG_arg_fail(1)) SWIG_fail;
44198 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44199
44200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44201 return resultobj;
44202 fail:
44203 return NULL;
44204 }
44205
44206
44207 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44208 PyObject *resultobj;
44209 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44210 wxIndividualLayoutConstraint *result;
44211 PyObject * obj0 = 0 ;
44212 char *kwnames[] = {
44213 (char *) "self", NULL
44214 };
44215
44216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44218 if (SWIG_arg_fail(1)) SWIG_fail;
44219 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44220
44221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44222 return resultobj;
44223 fail:
44224 return NULL;
44225 }
44226
44227
44228 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44229 PyObject *resultobj;
44230 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44231 wxIndividualLayoutConstraint *result;
44232 PyObject * obj0 = 0 ;
44233 char *kwnames[] = {
44234 (char *) "self", NULL
44235 };
44236
44237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44239 if (SWIG_arg_fail(1)) SWIG_fail;
44240 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44241
44242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44243 return resultobj;
44244 fail:
44245 return NULL;
44246 }
44247
44248
44249 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44250 PyObject *resultobj;
44251 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44252 wxIndividualLayoutConstraint *result;
44253 PyObject * obj0 = 0 ;
44254 char *kwnames[] = {
44255 (char *) "self", NULL
44256 };
44257
44258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44260 if (SWIG_arg_fail(1)) SWIG_fail;
44261 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44262
44263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44264 return resultobj;
44265 fail:
44266 return NULL;
44267 }
44268
44269
44270 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44271 PyObject *resultobj;
44272 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44273 wxIndividualLayoutConstraint *result;
44274 PyObject * obj0 = 0 ;
44275 char *kwnames[] = {
44276 (char *) "self", NULL
44277 };
44278
44279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44281 if (SWIG_arg_fail(1)) SWIG_fail;
44282 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44283
44284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44285 return resultobj;
44286 fail:
44287 return NULL;
44288 }
44289
44290
44291 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44292 PyObject *resultobj;
44293 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44294 wxIndividualLayoutConstraint *result;
44295 PyObject * obj0 = 0 ;
44296 char *kwnames[] = {
44297 (char *) "self", NULL
44298 };
44299
44300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44302 if (SWIG_arg_fail(1)) SWIG_fail;
44303 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44304
44305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44306 return resultobj;
44307 fail:
44308 return NULL;
44309 }
44310
44311
44312 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44313 PyObject *resultobj;
44314 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44315 wxIndividualLayoutConstraint *result;
44316 PyObject * obj0 = 0 ;
44317 char *kwnames[] = {
44318 (char *) "self", NULL
44319 };
44320
44321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44323 if (SWIG_arg_fail(1)) SWIG_fail;
44324 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44325
44326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44327 return resultobj;
44328 fail:
44329 return NULL;
44330 }
44331
44332
44333 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44334 PyObject *resultobj;
44335 wxLayoutConstraints *result;
44336 char *kwnames[] = {
44337 NULL
44338 };
44339
44340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44341 {
44342 PyThreadState* __tstate = wxPyBeginAllowThreads();
44343 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44344
44345 wxPyEndAllowThreads(__tstate);
44346 if (PyErr_Occurred()) SWIG_fail;
44347 }
44348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44349 return resultobj;
44350 fail:
44351 return NULL;
44352 }
44353
44354
44355 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44356 PyObject *resultobj;
44357 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44358 wxWindow *arg2 = (wxWindow *) 0 ;
44359 int *arg3 = (int *) 0 ;
44360 bool result;
44361 int temp3 ;
44362 int res3 = 0 ;
44363 PyObject * obj0 = 0 ;
44364 PyObject * obj1 = 0 ;
44365 char *kwnames[] = {
44366 (char *) "self",(char *) "win", NULL
44367 };
44368
44369 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44372 if (SWIG_arg_fail(1)) SWIG_fail;
44373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44374 if (SWIG_arg_fail(2)) SWIG_fail;
44375 {
44376 PyThreadState* __tstate = wxPyBeginAllowThreads();
44377 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44378
44379 wxPyEndAllowThreads(__tstate);
44380 if (PyErr_Occurred()) SWIG_fail;
44381 }
44382 {
44383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44384 }
44385 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44386 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj;
44395 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44396 bool result;
44397 PyObject * obj0 = 0 ;
44398 char *kwnames[] = {
44399 (char *) "self", NULL
44400 };
44401
44402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44404 if (SWIG_arg_fail(1)) SWIG_fail;
44405 {
44406 PyThreadState* __tstate = wxPyBeginAllowThreads();
44407 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44408
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 {
44413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44414 }
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44422 PyObject *obj;
44423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44424 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44425 Py_INCREF(obj);
44426 return Py_BuildValue((char *)"");
44427 }
44428 static PyMethodDef SwigMethods[] = {
44429 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44430 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44431 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44434 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44455 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44468 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44483 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44536 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44564 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44583 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44585 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44593 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44594 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44606 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44618 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44622 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44628 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44638 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44648 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44652 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44726 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44728 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44730 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44732 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44734 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44736 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44738 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44740 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44742 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44744 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44746 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44748 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44750 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44764 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44782 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44785 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44788 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44800 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44805 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44811 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44817 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44880 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44887 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44923 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44933 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"MoveEvent_m_pos_set", (PyCFunction) _wrap_MoveEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"MoveEvent_m_pos_get", (PyCFunction) _wrap_MoveEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"MoveEvent_m_rect_set", (PyCFunction) _wrap_MoveEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"MoveEvent_m_rect_get", (PyCFunction) _wrap_MoveEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44943 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44945 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44947 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44950 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44954 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44957 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44960 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44962 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44967 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44975 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44979 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44982 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44984 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44988 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45005 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45007 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45010 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45012 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45016 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45020 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45029 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45032 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45035 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45039 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45046 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45051 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45056 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45101 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45121 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45128 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45132 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45142 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45312 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45354 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45368 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45371 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45426 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45453 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45497 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45505 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45522 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45523 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45560 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45590 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45593 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45597 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45600 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45610 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45622 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"StdDialogButtonSizer_Finalise", (PyCFunction) _wrap_StdDialogButtonSizer_Finalise, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45634 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45668 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45675 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45676 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45677 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45678 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45679 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45684 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45711 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45723 { NULL, NULL, 0, NULL }
45724 };
45725
45726
45727 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45728
45729 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45730 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45731 }
45732 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45733 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45734 }
45735 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45736 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45737 }
45738 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45739 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45740 }
45741 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45742 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45743 }
45744 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45745 return (void *)((wxSizer *) ((wxGridSizer *) x));
45746 }
45747 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45748 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45749 }
45750 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45751 return (void *)((wxSizer *) ((wxPySizer *) x));
45752 }
45753 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45754 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45755 }
45756 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45757 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45758 }
45759 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45760 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45761 }
45762 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45763 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45764 }
45765 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45766 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45767 }
45768 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45769 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45770 }
45771 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45772 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45773 }
45774 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45775 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45776 }
45777 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45778 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45779 }
45780 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45781 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45782 }
45783 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45784 return (void *)((wxEvent *) ((wxPyEvent *) x));
45785 }
45786 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45787 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45788 }
45789 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45790 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45791 }
45792 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45793 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45794 }
45795 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45796 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45797 }
45798 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45799 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45800 }
45801 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45802 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45803 }
45804 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45805 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45806 }
45807 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45808 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45809 }
45810 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45811 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45812 }
45813 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45814 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45815 }
45816 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45817 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45818 }
45819 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45820 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45821 }
45822 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45823 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45824 }
45825 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45826 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45827 }
45828 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45829 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45830 }
45831 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45832 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45833 }
45834 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45835 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45836 }
45837 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45838 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45839 }
45840 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45841 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45842 }
45843 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45844 return (void *)((wxEvent *) ((wxShowEvent *) x));
45845 }
45846 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45847 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45848 }
45849 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45850 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45851 }
45852 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45853 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45854 }
45855 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45856 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45857 }
45858 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45859 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45860 }
45861 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45862 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45863 }
45864 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45865 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45866 }
45867 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45868 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45869 }
45870 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45871 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45872 }
45873 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45874 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45875 }
45876 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45877 return (void *)((wxControl *) ((wxControlWithItems *) x));
45878 }
45879 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45880 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45881 }
45882 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45883 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45884 }
45885 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45886 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45887 }
45888 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45889 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45890 }
45891 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45892 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45893 }
45894 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45895 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45896 }
45897 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45898 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45899 }
45900 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45901 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45902 }
45903 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45904 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45905 }
45906 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45907 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45908 }
45909 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45910 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45911 }
45912 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45913 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45914 }
45915 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45916 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45917 }
45918 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45919 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45920 }
45921 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45922 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45923 }
45924 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45925 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45926 }
45927 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45928 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45929 }
45930 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45931 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45932 }
45933 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45934 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45935 }
45936 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45937 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45938 }
45939 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45940 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45941 }
45942 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45943 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45944 }
45945 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45946 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45947 }
45948 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45949 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45950 }
45951 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45952 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45953 }
45954 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45955 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45956 }
45957 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45958 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45959 }
45960 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45961 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45962 }
45963 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45964 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45965 }
45966 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45967 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45968 }
45969 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45970 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45971 }
45972 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45973 return (void *)((wxObject *) ((wxSizerItem *) x));
45974 }
45975 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45976 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45977 }
45978 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45979 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45980 }
45981 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45982 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45983 }
45984 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45985 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45986 }
45987 static void *_p_wxSizerTo_p_wxObject(void *x) {
45988 return (void *)((wxObject *) ((wxSizer *) x));
45989 }
45990 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45991 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45992 }
45993 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45994 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45995 }
45996 static void *_p_wxEventTo_p_wxObject(void *x) {
45997 return (void *)((wxObject *) ((wxEvent *) x));
45998 }
45999 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46000 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46001 }
46002 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46003 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46004 }
46005 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46006 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46007 }
46008 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46009 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46010 }
46011 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46012 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46013 }
46014 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46015 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46016 }
46017 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46018 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46019 }
46020 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46021 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46022 }
46023 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46024 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46025 }
46026 static void *_p_wxControlTo_p_wxObject(void *x) {
46027 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46028 }
46029 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46030 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46031 }
46032 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46033 return (void *)((wxObject *) ((wxFSFile *) x));
46034 }
46035 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46036 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46037 }
46038 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46039 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46040 }
46041 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46042 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46043 }
46044 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46045 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46046 }
46047 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46048 return (void *)((wxObject *) ((wxMenuItem *) x));
46049 }
46050 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46051 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46052 }
46053 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46054 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46055 }
46056 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46057 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46058 }
46059 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46060 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46061 }
46062 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46063 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46064 }
46065 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46066 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46067 }
46068 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46069 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46070 }
46071 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46072 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46073 }
46074 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46075 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46076 }
46077 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46078 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46079 }
46080 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46081 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46082 }
46083 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46084 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46085 }
46086 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46087 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46088 }
46089 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46090 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46091 }
46092 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46093 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46094 }
46095 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46096 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46097 }
46098 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46099 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46100 }
46101 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46102 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46103 }
46104 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46105 return (void *)((wxObject *) ((wxImageHandler *) x));
46106 }
46107 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46108 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46109 }
46110 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46111 return (void *)((wxObject *) ((wxEvtHandler *) x));
46112 }
46113 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46114 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46115 }
46116 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46117 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46118 }
46119 static void *_p_wxImageTo_p_wxObject(void *x) {
46120 return (void *)((wxObject *) ((wxImage *) x));
46121 }
46122 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46123 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46124 }
46125 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46126 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46127 }
46128 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46129 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46130 }
46131 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46132 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46133 }
46134 static void *_p_wxWindowTo_p_wxObject(void *x) {
46135 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46136 }
46137 static void *_p_wxMenuTo_p_wxObject(void *x) {
46138 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46139 }
46140 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46141 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46142 }
46143 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46144 return (void *)((wxObject *) ((wxFileSystem *) x));
46145 }
46146 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46147 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46148 }
46149 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46150 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46151 }
46152 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46153 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46154 }
46155 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46156 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46157 }
46158 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46159 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46160 }
46161 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46162 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46163 }
46164 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46165 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46166 }
46167 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46168 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46169 }
46170 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46171 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46172 }
46173 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46174 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46175 }
46176 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46177 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46178 }
46179 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46180 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46181 }
46182 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46183 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46184 }
46185 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46186 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46187 }
46188 static void *_p_wxControlTo_p_wxWindow(void *x) {
46189 return (void *)((wxWindow *) ((wxControl *) x));
46190 }
46191 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46192 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46193 }
46194 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46195 return (void *)((wxWindow *) ((wxMenuBar *) x));
46196 }
46197 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46198 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46199 }
46200 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46201 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46202 }
46203 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46204 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46205 }
46206 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46207 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46208 }
46209 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46210 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46211 }
46212 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46213 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46214 }
46215 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46216 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46217 }
46218 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46219 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46220 }
46221 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46222 return (void *)((wxValidator *) ((wxPyValidator *) x));
46223 }
46224 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}};
46225 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}};
46226 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}};
46227 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}};
46228 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}};
46229 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}};
46230 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}};
46231 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}};
46232 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}};
46233 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}};
46234 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}};
46235 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}};
46236 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}};
46237 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_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_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_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_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}};
46238 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}};
46239 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}};
46240 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}};
46241 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}};
46242 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}};
46243 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}};
46244 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}};
46245 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}};
46246 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}};
46247 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}};
46248 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}};
46249 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}};
46250 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}};
46251 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}};
46252 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}};
46253 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}};
46254 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}};
46255 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}};
46256 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}};
46257 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}};
46258 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}};
46259 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}};
46260 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}};
46261 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}};
46262 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}};
46263 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}};
46264 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}};
46265 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}};
46266 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}};
46267 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}};
46268 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}};
46269 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}};
46270 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}};
46271 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}};
46272 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}};
46273 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}};
46274 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}};
46275 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}};
46276 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}};
46277 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}};
46278 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}};
46279 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}};
46280 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}};
46281 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}};
46282 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}};
46283 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}};
46284 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}};
46285 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}};
46286 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}};
46287 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}};
46288 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}};
46289 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}};
46290 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}};
46291 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}};
46292 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}};
46293 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}};
46294 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}};
46295 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}};
46296 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}};
46297 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}};
46298 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}};
46299 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}};
46300 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}};
46301 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}};
46302 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}};
46303 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}};
46304 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}};
46305 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}};
46306 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}};
46307 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}};
46308 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}};
46309 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}};
46310 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}};
46311 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}};
46312 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}};
46313 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}};
46314 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}};
46315 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}};
46316 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}};
46317 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_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_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_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}};
46318 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}};
46319 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}};
46320 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}};
46321 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}};
46322 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}};
46323 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}};
46324 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}};
46325 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}};
46326 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}};
46327 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}};
46328 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}};
46329 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}};
46330 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}};
46331 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}};
46332 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}};
46333 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}};
46334 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}};
46335 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}};
46336 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}};
46337 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}};
46338 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}};
46339 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_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}};
46340 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}};
46341 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}};
46342 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}};
46343 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}};
46344 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}};
46345 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}};
46346 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}};
46347 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}};
46348 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}};
46349 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}};
46350
46351 static swig_type_info *swig_types_initial[] = {
46352 _swigt__p_wxLayoutConstraints,
46353 _swigt__p_wxRealPoint,
46354 _swigt__p_wxSizerItem,
46355 _swigt__p_wxGBSizerItem,
46356 _swigt__p_wxScrollEvent,
46357 _swigt__p_wxEventLoop,
46358 _swigt__p_wxIndividualLayoutConstraint,
46359 _swigt__p_wxSizer,
46360 _swigt__p_wxBoxSizer,
46361 _swigt__p_wxStaticBoxSizer,
46362 _swigt__p_wxGridBagSizer,
46363 _swigt__p_wxAcceleratorEntry,
46364 _swigt__p_wxUpdateUIEvent,
46365 _swigt__p_wxEvent,
46366 _swigt__p_wxMenu,
46367 _swigt__p_wxGridSizer,
46368 _swigt__p_wxFlexGridSizer,
46369 _swigt__p_wxInitDialogEvent,
46370 _swigt__p_wxItemContainer,
46371 _swigt__p_wxNcPaintEvent,
46372 _swigt__p_wxPaintEvent,
46373 _swigt__p_wxSysColourChangedEvent,
46374 _swigt__p_wxMouseCaptureChangedEvent,
46375 _swigt__p_wxDisplayChangedEvent,
46376 _swigt__p_wxPaletteChangedEvent,
46377 _swigt__p_wxControl,
46378 _swigt__p_wxFont,
46379 _swigt__p_wxMenuBarBase,
46380 _swigt__p_wxSetCursorEvent,
46381 _swigt__p_wxFSFile,
46382 _swigt__p_wxCaret,
46383 _swigt__ptrdiff_t,
46384 _swigt__std__ptrdiff_t,
46385 _swigt__p_wxRegion,
46386 _swigt__p_wxPoint2D,
46387 _swigt__p_int,
46388 _swigt__p_wxSize,
46389 _swigt__p_wxDC,
46390 _swigt__p_wxPySizer,
46391 _swigt__p_wxVisualAttributes,
46392 _swigt__p_wxNotifyEvent,
46393 _swigt__p_wxPyEvent,
46394 _swigt__p_wxPropagationDisabler,
46395 _swigt__p_form_ops_t,
46396 _swigt__p_wxAppTraits,
46397 _swigt__p_wxArrayString,
46398 _swigt__p_wxShowEvent,
46399 _swigt__p_wxToolTip,
46400 _swigt__p_wxMoveEvent,
46401 _swigt__p_wxSizeEvent,
46402 _swigt__p_wxActivateEvent,
46403 _swigt__p_wxIconizeEvent,
46404 _swigt__p_wxMaximizeEvent,
46405 _swigt__p_wxQueryNewPaletteEvent,
46406 _swigt__p_wxWindowCreateEvent,
46407 _swigt__p_wxIdleEvent,
46408 _swigt__p_wxMenuItem,
46409 _swigt__p_wxStaticBox,
46410 _swigt__p_long,
46411 _swigt__p_wxDuplexMode,
46412 _swigt__p_wxTIFFHandler,
46413 _swigt__p_wxXPMHandler,
46414 _swigt__p_wxPNMHandler,
46415 _swigt__p_wxJPEGHandler,
46416 _swigt__p_wxPCXHandler,
46417 _swigt__p_wxGIFHandler,
46418 _swigt__p_wxPNGHandler,
46419 _swigt__p_wxANIHandler,
46420 _swigt__p_wxMemoryFSHandler,
46421 _swigt__p_wxZipFSHandler,
46422 _swigt__p_wxInternetFSHandler,
46423 _swigt__p_wxPyFileSystemHandler,
46424 _swigt__p_wxEvtHandler,
46425 _swigt__p_wxCURHandler,
46426 _swigt__p_wxICOHandler,
46427 _swigt__p_wxBMPHandler,
46428 _swigt__p_wxImageHandler,
46429 _swigt__p_wxFileSystemHandler,
46430 _swigt__p_wxRect,
46431 _swigt__p_wxButton,
46432 _swigt__p_wxGBSpan,
46433 _swigt__p_wxPropagateOnce,
46434 _swigt__p_wxAcceleratorTable,
46435 _swigt__p_wxStdDialogButtonSizer,
46436 _swigt__p_char,
46437 _swigt__p_wxGBPosition,
46438 _swigt__p_wxImage,
46439 _swigt__p_wxFrame,
46440 _swigt__p_wxScrollWinEvent,
46441 _swigt__p_wxPaperSize,
46442 _swigt__p_wxImageHistogram,
46443 _swigt__p_wxPoint,
46444 _swigt__p_wxCursor,
46445 _swigt__p_wxObject,
46446 _swigt__p_wxInputStream,
46447 _swigt__p_wxOutputStream,
46448 _swigt__p_wxPyInputStream,
46449 _swigt__p_wxDateTime,
46450 _swigt__p_wxKeyEvent,
46451 _swigt__p_wxNavigationKeyEvent,
46452 _swigt__p_wxWindowDestroyEvent,
46453 _swigt__p_unsigned_long,
46454 _swigt__p_wxWindow,
46455 _swigt__p_wxMenuBar,
46456 _swigt__p_wxFileSystem,
46457 _swigt__p_wxBitmap,
46458 _swigt__unsigned_int,
46459 _swigt__p_unsigned_int,
46460 _swigt__p_wxMenuEvent,
46461 _swigt__p_wxContextMenuEvent,
46462 _swigt__p_unsigned_char,
46463 _swigt__p_wxEraseEvent,
46464 _swigt__p_wxMouseEvent,
46465 _swigt__p_wxCloseEvent,
46466 _swigt__p_wxPyApp,
46467 _swigt__p_wxCommandEvent,
46468 _swigt__p_wxPyCommandEvent,
46469 _swigt__p_wxPyDropTarget,
46470 _swigt__p_wxQuantize,
46471 _swigt__p_wxChildFocusEvent,
46472 _swigt__p_wxFocusEvent,
46473 _swigt__p_wxDropFilesEvent,
46474 _swigt__p_wxControlWithItems,
46475 _swigt__p_wxColour,
46476 _swigt__p_wxValidator,
46477 _swigt__p_wxPyValidator,
46478 0
46479 };
46480
46481
46482 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46483
46484 static swig_const_info swig_const_table[] = {
46485 {0, 0, 0, 0.0, 0, 0}};
46486
46487 #ifdef __cplusplus
46488 }
46489 #endif
46490
46491
46492 #ifdef __cplusplus
46493 extern "C" {
46494 #endif
46495
46496 /* Python-specific SWIG API */
46497 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46498 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46499 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46500
46501 /* -----------------------------------------------------------------------------
46502 * global variable support code.
46503 * ----------------------------------------------------------------------------- */
46504
46505 typedef struct swig_globalvar {
46506 char *name; /* Name of global variable */
46507 PyObject *(*get_attr)(); /* Return the current value */
46508 int (*set_attr)(PyObject *); /* Set the value */
46509 struct swig_globalvar *next;
46510 } swig_globalvar;
46511
46512 typedef struct swig_varlinkobject {
46513 PyObject_HEAD
46514 swig_globalvar *vars;
46515 } swig_varlinkobject;
46516
46517 static PyObject *
46518 swig_varlink_repr(swig_varlinkobject *v) {
46519 v = v;
46520 return PyString_FromString("<Swig global variables>");
46521 }
46522
46523 static int
46524 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46525 swig_globalvar *var;
46526 flags = flags;
46527 fprintf(fp,"Swig global variables { ");
46528 for (var = v->vars; var; var=var->next) {
46529 fprintf(fp,"%s", var->name);
46530 if (var->next) fprintf(fp,", ");
46531 }
46532 fprintf(fp," }\n");
46533 return 0;
46534 }
46535
46536 static PyObject *
46537 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46538 swig_globalvar *var = v->vars;
46539 while (var) {
46540 if (strcmp(var->name,n) == 0) {
46541 return (*var->get_attr)();
46542 }
46543 var = var->next;
46544 }
46545 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46546 return NULL;
46547 }
46548
46549 static int
46550 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46551 swig_globalvar *var = v->vars;
46552 while (var) {
46553 if (strcmp(var->name,n) == 0) {
46554 return (*var->set_attr)(p);
46555 }
46556 var = var->next;
46557 }
46558 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46559 return 1;
46560 }
46561
46562 static PyTypeObject varlinktype = {
46563 PyObject_HEAD_INIT(0)
46564 0, /* Number of items in variable part (ob_size) */
46565 (char *)"swigvarlink", /* Type name (tp_name) */
46566 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46567 0, /* Itemsize (tp_itemsize) */
46568 0, /* Deallocator (tp_dealloc) */
46569 (printfunc) swig_varlink_print, /* Print (tp_print) */
46570 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46571 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46572 0, /* tp_compare */
46573 (reprfunc) swig_varlink_repr, /* tp_repr */
46574 0, /* tp_as_number */
46575 0, /* tp_as_sequence */
46576 0, /* tp_as_mapping */
46577 0, /* tp_hash */
46578 0, /* tp_call */
46579 0, /* tp_str */
46580 0, /* tp_getattro */
46581 0, /* tp_setattro */
46582 0, /* tp_as_buffer */
46583 0, /* tp_flags */
46584 0, /* tp_doc */
46585 #if PY_VERSION_HEX >= 0x02000000
46586 0, /* tp_traverse */
46587 0, /* tp_clear */
46588 #endif
46589 #if PY_VERSION_HEX >= 0x02010000
46590 0, /* tp_richcompare */
46591 0, /* tp_weaklistoffset */
46592 #endif
46593 #if PY_VERSION_HEX >= 0x02020000
46594 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46595 #endif
46596 #if PY_VERSION_HEX >= 0x02030000
46597 0, /* tp_del */
46598 #endif
46599 #ifdef COUNT_ALLOCS
46600 0,0,0,0 /* tp_alloc -> tp_next */
46601 #endif
46602 };
46603
46604 /* Create a variable linking object for use later */
46605 static PyObject *
46606 SWIG_Python_newvarlink(void) {
46607 swig_varlinkobject *result = 0;
46608 result = PyMem_NEW(swig_varlinkobject,1);
46609 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46610 result->ob_type = &varlinktype;
46611 result->vars = 0;
46612 result->ob_refcnt = 0;
46613 Py_XINCREF((PyObject *) result);
46614 return ((PyObject*) result);
46615 }
46616
46617 static void
46618 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46619 swig_varlinkobject *v;
46620 swig_globalvar *gv;
46621 v= (swig_varlinkobject *) p;
46622 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46623 gv->name = (char *) malloc(strlen(name)+1);
46624 strcpy(gv->name,name);
46625 gv->get_attr = get_attr;
46626 gv->set_attr = set_attr;
46627 gv->next = v->vars;
46628 v->vars = gv;
46629 }
46630
46631 /* -----------------------------------------------------------------------------
46632 * constants/methods manipulation
46633 * ----------------------------------------------------------------------------- */
46634
46635 /* Install Constants */
46636 static void
46637 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46638 PyObject *obj = 0;
46639 size_t i;
46640 for (i = 0; constants[i].type; i++) {
46641 switch(constants[i].type) {
46642 case SWIG_PY_INT:
46643 obj = PyInt_FromLong(constants[i].lvalue);
46644 break;
46645 case SWIG_PY_FLOAT:
46646 obj = PyFloat_FromDouble(constants[i].dvalue);
46647 break;
46648 case SWIG_PY_STRING:
46649 if (constants[i].pvalue) {
46650 obj = PyString_FromString((char *) constants[i].pvalue);
46651 } else {
46652 Py_INCREF(Py_None);
46653 obj = Py_None;
46654 }
46655 break;
46656 case SWIG_PY_POINTER:
46657 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46658 break;
46659 case SWIG_PY_BINARY:
46660 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46661 break;
46662 default:
46663 obj = 0;
46664 break;
46665 }
46666 if (obj) {
46667 PyDict_SetItemString(d,constants[i].name,obj);
46668 Py_DECREF(obj);
46669 }
46670 }
46671 }
46672
46673 /* -----------------------------------------------------------------------------*/
46674 /* Fix SwigMethods to carry the callback ptrs when needed */
46675 /* -----------------------------------------------------------------------------*/
46676
46677 static void
46678 SWIG_Python_FixMethods(PyMethodDef *methods,
46679 swig_const_info *const_table,
46680 swig_type_info **types,
46681 swig_type_info **types_initial) {
46682 size_t i;
46683 for (i = 0; methods[i].ml_name; ++i) {
46684 char *c = methods[i].ml_doc;
46685 if (c && (c = strstr(c, "swig_ptr: "))) {
46686 int j;
46687 swig_const_info *ci = 0;
46688 char *name = c + 10;
46689 for (j = 0; const_table[j].type; j++) {
46690 if (strncmp(const_table[j].name, name,
46691 strlen(const_table[j].name)) == 0) {
46692 ci = &(const_table[j]);
46693 break;
46694 }
46695 }
46696 if (ci) {
46697 size_t shift = (ci->ptype) - types;
46698 swig_type_info *ty = types_initial[shift];
46699 size_t ldoc = (c - methods[i].ml_doc);
46700 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46701 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46702 char *buff = ndoc;
46703 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46704 strncpy(buff, methods[i].ml_doc, ldoc);
46705 buff += ldoc;
46706 strncpy(buff, "swig_ptr: ", 10);
46707 buff += 10;
46708 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46709 methods[i].ml_doc = ndoc;
46710 }
46711 }
46712 }
46713 }
46714
46715 /* -----------------------------------------------------------------------------*
46716 * Initialize type list
46717 * -----------------------------------------------------------------------------*/
46718
46719 #if PY_MAJOR_VERSION < 2
46720 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46721 is copied out of Python/modsupport.c in python version 2.3.4 */
46722 static int
46723 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46724 {
46725 PyObject *dict;
46726 if (!PyModule_Check(m)) {
46727 PyErr_SetString(PyExc_TypeError,
46728 "PyModule_AddObject() needs module as first arg");
46729 return -1;
46730 }
46731 if (!o) {
46732 PyErr_SetString(PyExc_TypeError,
46733 "PyModule_AddObject() needs non-NULL value");
46734 return -1;
46735 }
46736
46737 dict = PyModule_GetDict(m);
46738 if (dict == NULL) {
46739 /* Internal error -- modules must have a dict! */
46740 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46741 PyModule_GetName(m));
46742 return -1;
46743 }
46744 if (PyDict_SetItemString(dict, name, o))
46745 return -1;
46746 Py_DECREF(o);
46747 return 0;
46748 }
46749 #endif
46750
46751 static swig_type_info **
46752 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46753 static PyMethodDef swig_empty_runtime_method_table[] = {
46754 {
46755 NULL, NULL, 0, NULL
46756 }
46757 };/* Sentinel */
46758
46759 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46760 swig_empty_runtime_method_table);
46761 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46762 if (pointer && module) {
46763 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46764 }
46765 return type_list_handle;
46766 }
46767
46768 static swig_type_info **
46769 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46770 swig_type_info **type_pointer;
46771
46772 /* first check if module already created */
46773 type_pointer = SWIG_Python_GetTypeListHandle();
46774 if (type_pointer) {
46775 return type_pointer;
46776 } else {
46777 /* create a new module and variable */
46778 return SWIG_Python_SetTypeListHandle(type_list_handle);
46779 }
46780 }
46781
46782 #ifdef __cplusplus
46783 }
46784 #endif
46785
46786 /* -----------------------------------------------------------------------------*
46787 * Partial Init method
46788 * -----------------------------------------------------------------------------*/
46789
46790 #ifdef SWIG_LINK_RUNTIME
46791 #ifdef __cplusplus
46792 extern "C"
46793 #endif
46794 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46795 #endif
46796
46797 #ifdef __cplusplus
46798 extern "C"
46799 #endif
46800 SWIGEXPORT(void) SWIG_init(void) {
46801 static PyObject *SWIG_globals = 0;
46802 static int typeinit = 0;
46803 PyObject *m, *d;
46804 int i;
46805 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46806
46807 /* Fix SwigMethods to carry the callback ptrs when needed */
46808 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46809
46810 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46811 d = PyModule_GetDict(m);
46812
46813 if (!typeinit) {
46814 #ifdef SWIG_LINK_RUNTIME
46815 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46816 #else
46817 # ifndef SWIG_STATIC_RUNTIME
46818 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46819 # endif
46820 #endif
46821 for (i = 0; swig_types_initial[i]; i++) {
46822 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46823 }
46824 typeinit = 1;
46825 }
46826 SWIG_InstallConstants(d,swig_const_table);
46827
46828
46829 #ifndef wxPyUSE_EXPORT
46830 // Make our API structure a CObject so other modules can import it
46831 // from this module.
46832 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46833 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46834 Py_XDECREF(cobj);
46835 #endif
46836
46837 {
46838 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46839 }
46840 {
46841 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46842 }
46843 {
46844 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46845 }
46846 {
46847 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46848 }
46849 {
46850 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46851 }
46852 {
46853 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46854 }
46855 {
46856 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46857 }
46858 {
46859 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46860 }
46861 {
46862 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46863 }
46864 {
46865 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46866 }
46867 {
46868 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46869 }
46870 {
46871 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46872 }
46873 {
46874 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46875 }
46876 {
46877 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46878 }
46879 {
46880 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46881 }
46882 {
46883 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46884 }
46885 {
46886 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46887 }
46888 {
46889 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46890 }
46891 {
46892 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46893 }
46894 {
46895 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46896 }
46897 {
46898 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46899 }
46900 {
46901 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46902 }
46903 {
46904 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46905 }
46906 {
46907 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46908 }
46909 {
46910 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46911 }
46912 {
46913 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46914 }
46915 {
46916 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46917 }
46918 {
46919 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46920 }
46921 {
46922 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46923 }
46924 {
46925 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46926 }
46927 {
46928 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46929 }
46930 {
46931 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46932 }
46933 {
46934 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46935 }
46936 {
46937 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46938 }
46939 {
46940 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46941 }
46942 {
46943 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46944 }
46945 {
46946 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46947 }
46948 {
46949 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46950 }
46951 {
46952 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46953 }
46954 {
46955 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46956 }
46957 {
46958 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46959 }
46960 {
46961 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46962 }
46963 {
46964 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46965 }
46966 {
46967 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46968 }
46969 {
46970 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46971 }
46972 {
46973 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46974 }
46975 {
46976 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46977 }
46978 {
46979 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46980 }
46981 {
46982 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46983 }
46984 {
46985 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46986 }
46987 {
46988 PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
46989 }
46990 {
46991 PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
46992 }
46993 {
46994 PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
46995 }
46996 {
46997 PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
46998 }
46999 {
47000 PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
47001 }
47002 {
47003 PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
47004 }
47005 {
47006 PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
47007 }
47008 {
47009 PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
47010 }
47011 {
47012 PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
47013 }
47014 {
47015 PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
47016 }
47017 {
47018 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47019 }
47020 {
47021 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47022 }
47023 {
47024 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47025 }
47026 {
47027 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47028 }
47029 {
47030 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47031 }
47032 {
47033 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47034 }
47035 {
47036 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47037 }
47038 {
47039 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47040 }
47041 {
47042 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47043 }
47044 {
47045 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47046 }
47047 {
47048 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47049 }
47050 {
47051 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47052 }
47053 {
47054 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47055 }
47056 {
47057 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47058 }
47059 {
47060 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47061 }
47062 {
47063 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47064 }
47065 {
47066 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47067 }
47068 {
47069 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47070 }
47071 {
47072 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47073 }
47074 {
47075 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47076 }
47077 {
47078 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47079 }
47080 {
47081 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47082 }
47083 {
47084 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47085 }
47086 {
47087 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47088 }
47089 {
47090 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47091 }
47092 {
47093 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47094 }
47095 {
47096 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47097 }
47098 {
47099 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47100 }
47101 {
47102 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47103 }
47104 {
47105 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47106 }
47107 {
47108 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47109 }
47110 {
47111 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47112 }
47113 {
47114 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47115 }
47116 {
47117 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47118 }
47119 {
47120 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47121 }
47122 {
47123 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47124 }
47125 {
47126 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47127 }
47128 {
47129 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47130 }
47131 {
47132 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48465 }
48466 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48467 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48468 {
48469 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48620 }
48621 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48622 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48623 {
48624 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48631 }
48632
48633 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48634
48635
48636 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48637
48638 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48639 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48640 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48641 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48642 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48643 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48644 {
48645 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48688 }
48689 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48690 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48691 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48692 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48693 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48694 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48695 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48696 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48697 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48698 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48699 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48700 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48701 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48702 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48703 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48704 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48705 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48706 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48707 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48708 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48709 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48710 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48711 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48712 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48713 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48714 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48715 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48716 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48717 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48718 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48719 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48720 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48721 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48722 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48723 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48724 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48725 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48726 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48727 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48728 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48729 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48730 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48731 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48732 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48733 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48734 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48735 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48736 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48737 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48738 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48739 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48740 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48741 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48742 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48743 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48744 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48745 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48746 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48747 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48748 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48749 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48750 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48751 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48752 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48753 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48754 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48755 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48756 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48757 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48758 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48759 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48760 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48761 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48762 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48763 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48764 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48765 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48766 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48767 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48768 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48769 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48770 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48771 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48772 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48773 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48774 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48775 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48776 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48777 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48778 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48779 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48780 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48781 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48782 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48783 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48784 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48785 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48786 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48787 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48788 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48789 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48790 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48791 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48792 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48793 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48794 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48795 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48796 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48797 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48798 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48799 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48800 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48801 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48802 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48803 {
48804 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48856 }
48857 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48858 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48859 {
48860 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48873 }
48874 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48875 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48876 {
48877 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48884 }
48885 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48886 {
48887 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48942 }
48943
48944 // Initialize threading, some globals and such
48945 __wxPyPreStart(d);
48946
48947
48948 // Although these are defined in __version__ they need to be here too so
48949 // that an assert can be done to ensure that the wxPython and the wxWindows
48950 // versions match.
48951 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48952 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48953 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48954
48955 }
48956
wxWidgets (Impactor)